Dsa Delphi DLL Reference Documentation

Dsa

Current Version: 11.5.0
Requires Chilkat Bundle License

Chilkat.Dsa

Generate, import, export, sign, and verify DSA keys and signatures.

Chilkat.Dsa is the Chilkat class for DSA key generation, DSA key import/export, DSA hash signing, and DSA signature verification. It supports private and public keys in DER, PEM, encrypted PEM, XML, explicit component, and OpenSSL parameter workflows. It also exposes DSA key components as hex-encoded SSH1-format bignums and provides helpers for working with encoded hashes and signatures.

Generate DSA keys

Create DSA key pairs and parameters for workflows that still require DSA-based signing or verification.

Import and export keys

Load and save private or public DSA keys in DER, PEM, encrypted PEM, XML, component-based, and OpenSSL-compatible formats.

Sign hashes

Create DSA signatures over message digests using a loaded private key and the appropriate encoded hash input.

Verify signatures

Verify DSA signatures using a public key, encoded hash, and signature data.

Key components

Access DSA parameters and key components as hex-encoded SSH1-format bignums for low-level interoperability scenarios.

Encoded data helpers

Work with encoded hashes and signatures when applications need hex, Base64, or other textual representations of binary values.

Common pattern: Load or generate a DSA key, compute the message hash with the desired hash algorithm, then use Dsa to sign the hash with the private key or verify the signature with the public key. For new protocol designs, consider whether a more modern signature algorithm is preferred; use this class when DSA is required for compatibility.

For an extended overview, see Dsa Class Overview.

Create/Dispose

var
myObject: HCkDsa;

begin
myObject := CkDsa_Create();

// ...

CkDsa_Dispose(myObject);
end;
function CkDsa_Create: HCkDsa; stdcall;

Creates an instance of the HCkDsa object and returns a handle (i.e. a Pointer). The handle is passed in the 1st argument for the functions listed on this page.

procedure CkDsa_Dispose(handle: HCkDsa); stdcall;

Objects created by calling CkDsa_Create must be freed by calling this method. A memory leak occurs if a handle is not disposed by calling this function.

Properties

DebugLogFilePath
procedure CkDsa_getDebugLogFilePath(objHandle: HCkDsa; outPropVal: HCkString); stdcall;
procedure CkDsa_putDebugLogFilePath(objHandle: HCkDsa; newPropVal: PWideChar); stdcall;
function CkDsa__debugLogFilePath(objHandle: HCkDsa): PWideChar; stdcall;

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.

See the notes about PWideChar memory ownership and validity.

More Information and Examples
Example showing how to use DebugLogFilePath.
top
GroupSize
function CkDsa_getGroupSize(objHandle: HCkDsa): Integer; stdcall;
procedure CkDsa_putGroupSize(objHandle: HCkDsa; newPropVal: Integer); stdcall;

Specifies the size, in bits, of the DSA subgroup parameter Q used by the legacy GenKey method. The default is 160. This also determines the natural size of the DSA signature components r and s.

Applications should normally leave this property at its default. When an explicit standards-era (L, N) parameter pair is required, use GenKey2, where L is the bit length of P and N is the bit length of Q.

Legacy algorithm: NIST FIPS 186-5 no longer approves DSA for generating new digital signatures. Retain DSA generation and signing only for interoperability with systems or data formats that specifically require it; DSA verification remains useful for legacy signatures.

top
HexG
procedure CkDsa_getHexG(objHandle: HCkDsa; outPropVal: HCkString); stdcall;
function CkDsa__hexG(objHandle: HCkDsa): PWideChar; stdcall;

Returns the DSA domain parameter G, the generator of the subgroup of order Q modulo P.

The returned text is a hexadecimal encoding of Chilkat's SSH1-format bignum representation, which includes a two-byte bit-length prefix followed by the unsigned integer bytes.

See the notes about PWideChar memory ownership and validity.

top
HexP
procedure CkDsa_getHexP(objHandle: HCkDsa; outPropVal: HCkString); stdcall;
function CkDsa__hexP(objHandle: HCkDsa): PWideChar; stdcall;

Returns the DSA domain parameter P, the large prime modulus.

The returned text is a hexadecimal encoding of Chilkat's SSH1-format bignum representation, which includes a two-byte bit-length prefix followed by the unsigned integer bytes.

See the notes about PWideChar memory ownership and validity.

top
HexQ
procedure CkDsa_getHexQ(objHandle: HCkDsa; outPropVal: HCkString); stdcall;
function CkDsa__hexQ(objHandle: HCkDsa): PWideChar; stdcall;

Returns the DSA domain parameter Q, a prime divisor of P - 1. The bit length of Q is commonly written as N and determines the range of the private value X and signature components r and s.

The returned text is a hexadecimal encoding of Chilkat's SSH1-format bignum representation, which includes a two-byte bit-length prefix followed by the unsigned integer bytes.

See the notes about PWideChar memory ownership and validity.

top
HexX
procedure CkDsa_getHexX(objHandle: HCkDsa; outPropVal: HCkString); stdcall;
function CkDsa__hexX(objHandle: HCkDsa): PWideChar; stdcall;

Returns the DSA private value X. It is present only when the object contains a private key and satisfies 0 < X < Q.

The returned text is a hexadecimal encoding of Chilkat's SSH1-format bignum representation, which includes a two-byte bit-length prefix followed by the unsigned integer bytes.

Sensitive value: Anyone who obtains X can create signatures as the key owner. Do not log, transmit, or persist this value unless it is protected as private-key material.

See the notes about PWideChar memory ownership and validity.

top
HexY
procedure CkDsa_getHexY(objHandle: HCkDsa; outPropVal: HCkString); stdcall;
function CkDsa__hexY(objHandle: HCkDsa): PWideChar; stdcall;

Returns the DSA public value Y, where Y = GX mod P. It is available when either a public or private DSA key is loaded.

The returned text is a hexadecimal encoding of Chilkat's SSH1-format bignum representation, which includes a two-byte bit-length prefix followed by the unsigned integer bytes.

See the notes about PWideChar memory ownership and validity.

top
LastErrorHtml
procedure CkDsa_getLastErrorHtml(objHandle: HCkDsa; outPropVal: HCkString); stdcall;
function CkDsa__lastErrorHtml(objHandle: HCkDsa): PWideChar; stdcall;

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.

See the notes about PWideChar memory ownership and validity.

top
LastErrorText
procedure CkDsa_getLastErrorText(objHandle: HCkDsa; outPropVal: HCkString); stdcall;
function CkDsa__lastErrorText(objHandle: HCkDsa): PWideChar; stdcall;

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.

See the notes about PWideChar memory ownership and validity.

More Information and Examples
Concept of LastErrorTextLastErrorText Standard Information
top
LastErrorXml
procedure CkDsa_getLastErrorXml(objHandle: HCkDsa; outPropVal: HCkString); stdcall;
function CkDsa__lastErrorXml(objHandle: HCkDsa): PWideChar; stdcall;

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.

See the notes about PWideChar memory ownership and validity.

top
LastMethodSuccess
function CkDsa_getLastMethodSuccess(objHandle: HCkDsa): wordbool; stdcall;
procedure CkDsa_putLastMethodSuccess(objHandle: HCkDsa; newPropVal: wordbool); stdcall;

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
UncommonOptions
procedure CkDsa_getUncommonOptions(objHandle: HCkDsa; outPropVal: HCkString); stdcall;
procedure CkDsa_putUncommonOptions(objHandle: HCkDsa; newPropVal: PWideChar); stdcall;
function CkDsa__uncommonOptions(objHandle: HCkDsa): PWideChar; stdcall;
Introduced in version 9.5.0.90

Reserved for uncommon or compatibility-specific options. The default is the empty string, and applications should normally leave this property unchanged unless Chilkat documentation or support identifies a specific keyword required for the target system.

See the notes about PWideChar memory ownership and validity.

top
VerboseLogging
function CkDsa_getVerboseLogging(objHandle: HCkDsa): wordbool; stdcall;
procedure CkDsa_putVerboseLogging(objHandle: HCkDsa; newPropVal: wordbool); stdcall;

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
procedure CkDsa_getVersion(objHandle: HCkDsa; outPropVal: HCkString); stdcall;
function CkDsa__version(objHandle: HCkDsa): PWideChar; stdcall;

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

See the notes about PWideChar memory ownership and validity.

More Information and Examples
How to get the Chilkat version at runtime.
top

Methods

FromDerBd
function CkDsa_FromDerBd(objHandle: HCkDsa;
    bd: HCkBinData): wordbool; stdcall;
Introduced in version 11.0.0

Loads a DSA private key from the DER bytes contained in the BinData object passed in bd. Returns True on successful decoding.

Private-key handling: The BinData content contains secret key material and should be cleared or released when no longer needed.

Returns True for success, False for failure.

top
FromDerFile
function CkDsa_FromDerFile(objHandle: HCkDsa;
    path: PWideChar): wordbool; stdcall;

Loads a DSA private key from the DER-encoded file specified by path. Returns True when the file is read and decoded successfully; otherwise returns False.

Private-key handling: Restrict access to the file because it contains secret key material. Check LastErrorText when loading fails.

Returns True for success, False for failure.

More Information and Examples
Convert DSA DER Private Key to PEM
top
FromEncryptedPem
function CkDsa_FromEncryptedPem(objHandle: HCkDsa;
    password: PWideChar;
    pemData: PWideChar): wordbool; stdcall;

Loads a DSA private key from the PEM text in pemData. password supplies the password when the PEM is encrypted. If the PEM is unencrypted, the password is ignored and the key is loaded normally.

Returns True on success and False if the PEM cannot be decoded, the password is incorrect, or the contained key is not a supported DSA private key.

Security: Do not embed production passwords in source code or log the PEM text. Prefer protected secret storage and encrypted private-key files where practical.

Returns True for success, False for failure.

top
FromPem
function CkDsa_FromPem(objHandle: HCkDsa;
    pemData: PWideChar): wordbool; stdcall;

Loads an unencrypted DSA private key from the PEM text in pemData. On success, the object contains the private key and its corresponding public components.

Unencrypted private key: PEM armor is only a text encoding; it does not protect the private key. Treat the string as highly sensitive and use FromEncryptedPem when password-protected PEM is available.

Returns True for success, False for failure.

More Information and Examples
DSA Signature Create and Verify
top
FromPublicDerBd
function CkDsa_FromPublicDerBd(objHandle: HCkDsa;
    bd: HCkBinData): wordbool; stdcall;
Introduced in version 11.0.0

Loads a DSA public key from the DER bytes contained in the BinData object passed in bd. The resulting key can verify signatures but cannot sign.

Returns True for success, False for failure.

top
FromPublicDerFile
function CkDsa_FromPublicDerFile(objHandle: HCkDsa;
    path: PWideChar): wordbool; stdcall;

Loads a DSA public key from the DER-encoded file specified by path. Returns True when the file is read and decoded successfully; otherwise returns False.

Returns True for success, False for failure.

top
FromPublicPem
function CkDsa_FromPublicPem(objHandle: HCkDsa;
    pemData: PWideChar): wordbool; stdcall;

Loads a DSA public key from the PEM text in pemData. Returns True when the PEM contains a supported DSA public key and is decoded successfully.

Returns True for success, False for failure.

top
FromXml
function CkDsa_FromXml(objHandle: HCkDsa;
    xmlKey: PWideChar): wordbool; stdcall;

Loads a DSA public or private key from the XML text in xmlKey. The XML content determines whether the resulting object contains public components only or also includes the private value X.

Security: XML is only a representation format. If the XML contains X, it contains the complete private key and must be protected accordingly.

Returns True for success, False for failure.

top
GenKey
function CkDsa_GenKey(objHandle: HCkDsa;
    numBits: Integer): wordbool; stdcall;

Generates a new DSA key pair with a P size of numBits bits. numBits must be at least 1024 and a multiple of 64. This legacy method uses the subgroup size selected by GroupSize, whose default is 160 bits.

For explicit standard parameter pairs such as (2048, 224) or (3072, 256), use GenKey2.

Legacy algorithm: DSA signature generation is no longer approved by FIPS 186-5. Generate new DSA keys only when required for compatibility with an existing protocol, key store, or signature format.

Returns True for success, False for failure.

More Information and Examples
DSA Generate Key
top
GenKey2
function CkDsa_GenKey2(objHandle: HCkDsa;
    keyLenBits: Integer;
    modLenBits: Integer): wordbool; stdcall;
Introduced in version 9.5.0.90

Generates a new DSA key pair using an explicit (L, N) parameter-size combination. keyLenBits is L, the bit length of the prime modulus P. modLenBits is N, the bit length of the subgroup prime Q.

LNHistorical FIPS 186-4 combination
1024160Legacy
2048224 or 256Supported parameter pairs
3072256Largest listed pair
Current standards status: These combinations come from the superseded FIPS 186-4 DSA specification. FIPS 186-5 no longer approves DSA signature generation; use this method only for compatibility.

Returns True for success, False for failure.

top
GenKeyFromParamsDerBd
function CkDsa_GenKeyFromParamsDerBd(objHandle: HCkDsa;
    bd: HCkBinData): wordbool; stdcall;
Introduced in version 11.0.0

Generates a new DSA key pair from OpenSSL-style DSA parameters stored as DER bytes in the BinData object passed in bd.

The supplied data contains DSA domain parameters P, Q, and G, not an existing private key. Chilkat validates or imports those parameters and generates a fresh private value X and corresponding public value Y.

Returns True for success, False for failure.

top
GenKeyFromParamsDerFile
function CkDsa_GenKeyFromParamsDerFile(objHandle: HCkDsa;
    path: PWideChar): wordbool; stdcall;

Generates a new DSA key pair from the OpenSSL-style DER DSA-parameters file specified by path.

The supplied data contains DSA domain parameters P, Q, and G, not an existing private key. Chilkat validates or imports those parameters and generates a fresh private value X and corresponding public value Y.

Returns True when the parameters are loaded and a key pair is generated successfully.

Returns True for success, False for failure.

More Information and Examples
Generate new DSA Key from OpenSSL Parameters File
top
GenKeyFromParamsPem
function CkDsa_GenKeyFromParamsPem(objHandle: HCkDsa;
    pem: PWideChar): wordbool; stdcall;

Generates a new DSA key pair from OpenSSL-style DSA parameters supplied as PEM text in pem.

The supplied data contains DSA domain parameters P, Q, and G, not an existing private key. Chilkat validates or imports those parameters and generates a fresh private value X and corresponding public value Y.

Returns True for success, False for failure.

top
GenKeyFromParamsPemFile
function CkDsa_GenKeyFromParamsPemFile(objHandle: HCkDsa;
    path: PWideChar): wordbool; stdcall;

Generates a new DSA key pair from the OpenSSL-style PEM DSA-parameters file specified by path.

The supplied data contains DSA domain parameters P, Q, and G, not an existing private key. Chilkat validates or imports those parameters and generates a fresh private value X and corresponding public value Y.

A typical parameter file is PEM-armored with a BEGIN DSA PARAMETERS header. The newly generated private key can be exported with the applicable To* methods.

Returns True for success, False for failure.

top
GenKeyFromPQG
function CkDsa_GenKeyFromPQG(objHandle: HCkDsa;
    pHex: PWideChar;
    qHex: PWideChar;
    gHex: PWideChar): wordbool; stdcall;
Introduced in version 9.5.0.90

Generates a new DSA private/public key pair using the preselected domain parameters P, Q, and G supplied in pHex, qHex, and gHex.

Each argument is hexadecimal text in Chilkat's SSH1-format bignum representation. Chilkat generates a fresh private value X and derives Y; the supplied values are domain parameters, not an existing key pair.

Parameter provenance: Only use DSA parameters obtained from a trusted, validated source. Malformed or maliciously chosen domain parameters can undermine signature security.

Returns True for success, False for failure.

top
GetEncodedHash
function CkDsa_GetEncodedHash(objHandle: HCkDsa;
    encoding: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkDsa__getEncodedHash(objHandle: HCkDsa;
    encoding: PWideChar): PWideChar; stdcall;

Returns the current Hash bytes encoded according to encoding. Use hex or base64.

This method does not compute a hash; it only converts the bytes already stored in the Hash property to text.

Returns True for success, False for failure.

See the notes about PWideChar memory ownership and validity.

top
GetEncodedSignature
function CkDsa_GetEncodedSignature(objHandle: HCkDsa;
    encoding: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkDsa__getEncodedSignature(objHandle: HCkDsa;
    encoding: PWideChar): PWideChar; stdcall;

Returns the current Signature bytes encoded according to encoding. Use hex or base64.

After a successful SignHash call, the returned bytes are the ASN.1 DER-encoded DSA signature containing the integers r and s.

Returns True for success, False for failure.

See the notes about PWideChar memory ownership and validity.

top
LoadText
function CkDsa_LoadText(objHandle: HCkDsa;
    path: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkDsa__loadText(objHandle: HCkDsa;
    path: PWideChar): PWideChar; stdcall;

Loads the entire file specified by path and returns its contents as text using the legacy ANSI character encoding.

Encoding note: This convenience method is suitable for ASCII-compatible PEM and similar legacy text. It is not a general Unicode file reader; use an API with an explicit character encoding when UTF-8 or other Unicode text must be preserved.

Returns True for success, False for failure.

See the notes about PWideChar memory ownership and validity.

top
SaveText
function CkDsa_SaveText(objHandle: HCkDsa;
    strToSave: PWideChar;
    path: PWideChar): wordbool; stdcall;

Writes strToSave to the file specified by path using the legacy ANSI character encoding. Returns True on success.

Encoding note: This convenience method is appropriate for ASCII-compatible PEM text. It can lose characters that are not representable in the active ANSI encoding, so use an explicitly encoded text-writing API for general Unicode content.

Returns True for success, False for failure.

top
SetEncodedHash
function CkDsa_SetEncodedHash(objHandle: HCkDsa;
    encoding: PWideChar;
    encodedHash: PWideChar): wordbool; stdcall;

Decodes encodedHash using the encoding named by encoding and stores the resulting bytes in the Hash property. Use hex or base64.

The decoded value must be the already-computed message digest that will be signed by SignHash or checked by Verify.

Returns True for success, False for failure.

top
SetEncodedSignature
function CkDsa_SetEncodedSignature(objHandle: HCkDsa;
    encoding: PWideChar;
    encodedSig: PWideChar): wordbool; stdcall;

Decodes the signature text in encodedSig using the encoding named by encoding and stores the resulting bytes in the Signature property. Use hex or base64.

The decoded bytes are expected to contain the ASN.1 DER-encoded DSA signature. Set the corresponding Hash and public key before calling Verify.

Returns True for success, False for failure.

top
SetEncodedSignatureRS
function CkDsa_SetEncodedSignatureRS(objHandle: HCkDsa;
    encoding: PWideChar;
    encodedR: PWideChar;
    encodedS: PWideChar): wordbool; stdcall;

Builds the DSA signature from separately encoded r and s integer values. encoding identifies the encoding used by both encodedR and encodedS; use hex or base64.

On success, Signature contains the ASN.1 DER SEQUENCE of the two integers and is ready for use with Verify.

Returns True for success, False for failure.

top
SetKeyExplicit
function CkDsa_SetKeyExplicit(objHandle: HCkDsa;
    groupSizeInBytes: Integer;
    pHex: PWideChar;
    qHex: PWideChar;
    gHex: PWideChar;
    xHex: PWideChar): wordbool; stdcall;

Loads a DSA private key from explicitly supplied components. groupSizeInBytes is the size of Q in bytes. pHex, qHex, gHex, and xHex provide P, Q, G, and the private value X, respectively.

The corresponding public value Y = GX mod P is derived from the private key.

SSH1 bignums: Each component string is hexadecimal text representing an SSH1-format bignum: a two-byte bit-length prefix followed by the unsigned integer bytes.
Sensitive value: xHex contains the private key. Do not expose it in logs or transmit it over an unprotected channel.

Returns True for success, False for failure.

top
SetPubKeyExplicit
function CkDsa_SetPubKeyExplicit(objHandle: HCkDsa;
    groupSizeInBytes: Integer;
    pHex: PWideChar;
    qHex: PWideChar;
    gHex: PWideChar;
    yHex: PWideChar): wordbool; stdcall;

Loads a DSA public key from explicitly supplied components. groupSizeInBytes is the size of Q in bytes. pHex, qHex, gHex, and yHex provide P, Q, G, and the public value Y, respectively.

The resulting object can verify DSA signatures but cannot create them.

SSH1 bignums: Each component string is hexadecimal text representing an SSH1-format bignum: a two-byte bit-length prefix followed by the unsigned integer bytes.

Returns True for success, False for failure.

top
SignHash
function CkDsa_SignHash(objHandle: HCkDsa): wordbool; stdcall;

Creates a DSA signature over the digest currently stored in Hash. A DSA private key must be loaded, and the digest must be set directly or with SetEncodedHash before this method is called.

On success, Signature contains an ASN.1 DER-encoded sequence of the DSA values r and s. Retrieve it with GetEncodedSignature or read the Signature property.

Security-critical nonce: Each DSA signature requires a secret per-signature value. Reuse or poor generation of that value can reveal the private key. Chilkat performs this generation internally; applications should not attempt to reuse signature state.
Standards status: FIPS 186-5 no longer approves DSA for generating new signatures. Use this method only for required legacy interoperability.

Returns True for success, False for failure.

More Information and Examples
DSA Signature Create and Verify
top
ToDerBd
function CkDsa_ToDerBd(objHandle: HCkDsa;
    bd: HCkBinData): wordbool; stdcall;
Introduced in version 11.0.0

Writes the DER-encoded DSA private key to the BinData object passed in bd. Returns True on success.

Sensitive output: The destination contains unencrypted private-key bytes after a successful call. Protect and clear it appropriately.

Returns True for success, False for failure.

top
ToDerFile
function CkDsa_ToDerFile(objHandle: HCkDsa;
    path: PWideChar): wordbool; stdcall;

Writes the loaded DSA private key to the DER file specified by path. Returns True on success.

Sensitive output: The file contains unencrypted private-key material. Apply restrictive filesystem permissions and avoid writing it to shared or temporary locations.

Returns True for success, False for failure.

More Information and Examples
DSA Generate Key
top
ToEncryptedPem
function CkDsa_ToEncryptedPem(objHandle: HCkDsa;
    password: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkDsa__toEncryptedPem(objHandle: HCkDsa;
    password: PWideChar): PWideChar; stdcall;

Returns the loaded DSA private key as password-encrypted PEM text using password as the password.

Password protection: Use a strong password and protect it separately from the PEM. Encrypted PEM reduces exposure at rest but does not make it safe to log or transmit indiscriminately.

Returns True for success, False for failure.

See the notes about PWideChar memory ownership and validity.

More Information and Examples
DSA Generate KeyConvert DSA DER Private Key to PEM
top
ToPem
function CkDsa_ToPem(objHandle: HCkDsa;
    outStr: HCkString): wordbool; stdcall;
function CkDsa__toPem(objHandle: HCkDsa): PWideChar; stdcall;

Returns the loaded DSA private key as unencrypted PEM text.

Unencrypted private key: PEM armor is not encryption. Anyone who obtains this text can use the private key, so prefer ToEncryptedPem when password protection is required.

Returns True for success, False for failure.

See the notes about PWideChar memory ownership and validity.

More Information and Examples
Convert DSA DER Private Key to PEM
top
ToPublicDerFile
function CkDsa_ToPublicDerFile(objHandle: HCkDsa;
    path: PWideChar): wordbool; stdcall;

Writes the public portion of the loaded DSA key to the DER file specified by path. Returns True on success.

Returns True for success, False for failure.

More Information and Examples
DSA Generate Key
top
ToPublicPem
function CkDsa_ToPublicPem(objHandle: HCkDsa;
    outStr: HCkString): wordbool; stdcall;
function CkDsa__toPublicPem(objHandle: HCkDsa): PWideChar; stdcall;

Returns the public portion of the loaded DSA key as PEM text. Public-key PEM may be distributed to parties that need to verify signatures; it does not contain the private value X.

Returns True for success, False for failure.

See the notes about PWideChar memory ownership and validity.

More Information and Examples
DSA Generate Key
top
ToXml
function CkDsa_ToXml(objHandle: HCkDsa;
    bPublicOnly: wordbool;
    outStr: HCkString): wordbool; stdcall;
function CkDsa__toXml(objHandle: HCkDsa;
    bPublicOnly: wordbool): PWideChar; stdcall;

Returns the loaded DSA key as XML. Set bPublicOnly to True to export public components only. Set it to False to include the private component when a private key is loaded.

Security: When bPublicOnly is False, the XML can contain the private value X. Protect it as private-key material.

Returns True for success, False for failure.

See the notes about PWideChar memory ownership and validity.

More Information and Examples
DSA Get Key as XML
top
Verify
function CkDsa_Verify(objHandle: HCkDsa): wordbool; stdcall;

Verifies the DSA signature currently stored in Signature against the digest stored in Hash, using the loaded public key. Both values must be set before calling this method.

Returns True only when the signature is valid. A False result can indicate an invalid signature, malformed input, an incompatible key, or another operational error; inspect LastErrorText when the reason matters.

Returns True for success, False for failure.

More Information and Examples
DSA Signature Create and VerifyDSA R,S Signature Values
top
VerifyKey
function CkDsa_VerifyKey(objHandle: HCkDsa): wordbool; stdcall;

Checks the mathematical validity and internal consistency of the DSA public or private key currently loaded in the object. Returns True when the key parameters and available key components pass validation.

This does not establish who owns the key, whether the key came from a trusted source, or whether it is suitable for a particular protocol.

More Information and Examples
DSA Signature Create and Verify
top

Deprecated

FromDer Deprecated
function CkDsa_FromDer(objHandle: HCkDsa;
    derData: HCkByteData): wordbool; stdcall;

Loads a DSA private key from the DER-encoded bytes in derData. On success, the object contains both the private and public key components and can sign or verify digests.

Private-key handling: The input contains secret key material. Keep it out of logs and protect any storage or transport that carries these bytes.

Returns True for success, False for failure.

top
FromPublicDer Deprecated
function CkDsa_FromPublicDer(objHandle: HCkDsa;
    derData: HCkByteData): wordbool; stdcall;

Loads a DSA public key from the DER-encoded bytes in derData. A public key can be used with Verify and can be exported, but it cannot be used by SignHash.

Returns True for success, False for failure.

top
GenKeyFromParamsDer Deprecated
function CkDsa_GenKeyFromParamsDer(objHandle: HCkDsa;
    derBytes: HCkByteData): wordbool; stdcall;

Generates a new DSA key pair from OpenSSL-style DSA parameters supplied as DER-encoded bytes in derBytes.

The supplied data contains DSA domain parameters P, Q, and G, not an existing private key. Chilkat validates or imports those parameters and generates a fresh private value X and corresponding public value Y.

Returns True for success, False for failure.

top
ToDer Deprecated
function CkDsa_ToDer(objHandle: HCkDsa;
    outBytes: HCkByteData): wordbool; stdcall;

Returns the loaded DSA private key as DER-encoded bytes. A private key must be present; a public-only key cannot be exported by this method.

Sensitive output: The returned bytes contain the private key and must be protected in memory, storage, and transit.

Returns True for success, False for failure.

top
ToPublicDer Deprecated
function CkDsa_ToPublicDer(objHandle: HCkDsa;
    outBytes: HCkByteData): wordbool; stdcall;

Returns the public portion of the loaded DSA key as DER-encoded bytes. This works whether the object contains a public key or a private key with a corresponding public value.

Returns True for success, False for failure.

top
ToPublicDerBd Deprecated
function CkDsa_ToPublicDerBd(objHandle: HCkDsa;
    bd: HCkBinData): wordbool; stdcall;
Introduced in version 11.0.0

Writes the DER-encoded public portion of the loaded DSA key to the BinData object passed in bd. Returns True on success.

Returns True for success, False for failure.

top