---
product: Chilkat
product_version: 11.7.0
language: pascal
language_label: Lazarus Pascal
class: Dkim
license: bundle
deprecated: false
reference_html: https://www.chilkatsoft.com/refdoc/pascal_DkimRef.html
---
# Chilkat Dkim — Lazarus Pascal — v11.7.0

> Chilkat 11.7.0 · language=pascal · class=Dkim
> Other versions: replace `11.7.0` in this URL. Other languages: `https://www.chilkatsoft.com/ai-docs/v/11.7.0/<lang>/classes/Dkim.md`.
> Language-wide rules (install, unlock, error model, strings/bytes): `https://www.chilkatsoft.com/ai-docs/v/11.7.0/pascal/guide.md`.

## Purpose

**Sign and verify MIME email with DKIM signatures.**

`Chilkat.Dkim` is the Chilkat class for applying and verifying DKIM signatures on MIME email data. It supports DKIM signing with `rsa-sha256` or `rsa-sha1`, configurable canonicalization, selectable signed headers, signature counting, DNS public-key lookup, public-key caching, public-key prefetching, and detailed verification reporting through `VerifyInfo`.

**DKIM signing**

Add DKIM signatures to MIME messages using a private key, selector, signing domain, canonicalization settings, and selected headers.

**Signed header selection**

Choose which message headers are protected by the signature and control their order in the generated `h=` tag.

**Signature verification**

Verify one or more signatures in a MIME message and determine whether the signed content, headers, and public key match.

**Canonicalization control**

Configure body and header canonicalization so signing and verification match the requirements of the sending domain and receiving systems.

**DNS public keys**

Retrieve DKIM public keys from DNS, prefetch keys when useful, and cache public keys to reduce repeated DNS lookups.

**Verification diagnostics**

Use `VerifyInfo` and related status information to understand which signatures were found, which were checked, and why verification succeeded or failed.

**Common pattern:** To sign, provide the MIME message, signing domain, selector, private key, canonicalization choices, and the headers to include in the signature. To verify, pass the received MIME message to `Dkim`, allow the class to locate the signature and public key, and inspect `VerifyInfo` for detailed results.

For an extended overview, see [Dkim Class Overview](https://www.chilkatsoft.com/dkim_class_overview.asp).

## Object creation, unlocking and error handling

**Create / Free**

```pascal
uses
  Chilkat.Dkim;

var
  obj: TDkim;
begin
  obj := TDkim.Create;
  try
    if not obj.IsValid then
      raise Exception.Create('Failed to create a TDkim instance.');

    // ... use obj ...

  finally
    obj.Free;
  end;
end;
```

`constructor Create;`

Allocates the underlying CkDkim object and returns a new TDkim instance. Simply adding **Chilkat.Dkim** to the unit's `uses` clause is enough to locate and bind to the Chilkat shared library (DLL / .so / .dylib) at runtime — no separate load step is required. Check `obj.IsValid` after calling `Create`; it is `False` if the underlying library could not be found/loaded or the object could not be allocated (for example, when unlicensed).

`destructor Destroy; override;`

Every TDkim created by calling `Create` should eventually be released by calling `.Free` (inherited from `TObject`). The destructor automatically disposes the underlying CkDkim handle. A native (unmanaged) memory leak occurs if the object is never freed.

Call `Global.UnlockBundle` once at the start of the program, before using this or any other Chilkat class. Any string unlocks a fully functional 30-day trial; a purchased unlock code is used in production. See `guide.md` for the exact code in Lazarus Pascal.

## Members common to every Chilkat class

Documented once per language in `common-members.md`; listed here so this page is self-contained.

| Property | Signature | Access | Meaning |
|---|---|---|---|
| `DebugLogFilePath` | `property DebugLogFilePath: string read GetDebugLogFilePath write SetDebugLogFilePath;` | read/write | If set to a file path, this property logs the LastErrorText of each Chilkat method or property call to the specified file. |
| `LastErrorHtml` | `property LastErrorHtml: string read GetLastErrorHtml;` | read-only | Provides HTML-formatted information about the last called method or property. |
| `LastErrorText` | `property LastErrorText: string read GetLastErrorText;` | read-only | Provides plain text information about the last called method or property. |
| `LastErrorXml` | `property LastErrorXml: string read GetLastErrorXml;` | read-only | Provides XML-formatted information about the last called method or property. |
| `LastMethodSuccess` | `property LastMethodSuccess: Boolean read GetLastMethodSuccess write SetLastMethodSuccess;` | read/write | Indicates the success or failure of the most recent method call: `True` means success, `False` means failure. |
| `VerboseLogging` | `property VerboseLogging: Boolean read GetVerboseLogging write SetVerboseLogging;` | read/write | If set to `True`, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may contain more verbose information. |
| `Version` | `property Version: string read GetVersion;` | read-only | Version of the component/library, such as "10.1.0" |

## Member index

| Member | Kind | Signature |
|---|---|---|
| `AbortCurrent` | property, read/write | `property AbortCurrent: Boolean read GetAbortCurrent write SetAbortCurrent;` |
| `DkimAlg` | property, read/write | `property DkimAlg: string read GetDkimAlg write SetDkimAlg;` |
| `DkimBodyLengthCount` | property, read/write | `property DkimBodyLengthCount: Integer read GetDkimBodyLengthCount write SetDkimBodyLengthCount;` |
| `DkimCanon` | property, read/write | `property DkimCanon: string read GetDkimCanon write SetDkimCanon;` |
| `DkimDomain` | property, read/write | `property DkimDomain: string read GetDkimDomain write SetDkimDomain;` |
| `DkimHeaders` | property, read/write | `property DkimHeaders: string read GetDkimHeaders write SetDkimHeaders;` |
| `DkimSelector` | property, read/write | `property DkimSelector: string read GetDkimSelector write SetDkimSelector;` |
| `HeartbeatMs` | property, read/write | `property HeartbeatMs: Integer read GetHeartbeatMs write SetHeartbeatMs;` |
| `VerifyInfo` | property, read-only | `property VerifyInfo: string read GetVerifyInfo;` |
| `DkimSign` | method | `// mimeData is a TBinData object. function DkimSign(mimeData: TChilkatBase): Boolean;` |
| `DkimVerify` | method | `// mimeData is a TBinData object. function DkimVerify(sigIndex: Integer;     mimeData: TChilkatBase): Boolean;` |
| `LoadPublicKey` | method | `function LoadPublicKey(const selector: string;     const domain: string;     const publicKey: string): Boolean;` |
| `LoadPublicKeyFile` | method | `function LoadPublicKeyFile(const selector: string;     const domain: string;     const publicKeyFilepath: string): Boolean;` |
| `LoadTaskCaller` | method | `// task is a TTask object. function LoadTaskCaller(task: TChilkatBase): Boolean;` |
| `NumDkimSigs` | method | `// mimeData is a TBinData object. function NumDkimSigs(mimeData: TChilkatBase): Integer;` |
| `PrefetchPublicKey` | method | `function PrefetchPublicKey(const selector: string;     const domain: string): Boolean;` |
| `SetDkimPrivateKey` | method | `// privateKey is a TPrivateKey object. function SetDkimPrivateKey(privateKey: TChilkatBase): Boolean;` |

## Properties

### Dkim.AbortCurrent

`Chilkat 11.7.0 · pascal · Dkim · AbortCurrent · property · read/write · since 9.5.0.58`

```pascal
property AbortCurrent: Boolean read GetAbortCurrent write SetAbortCurrent;
```

Set to `True` to request cancellation of a currently running operation. A synchronous operation can be cancelled from another thread by setting this property on the same object. Methods that complete quickly or do not periodically check for cancellation may finish before the request is observed.

**Cancellation behavior:** Treat this as a cancellation request rather than a guarantee of immediate termination. After the method returns, use the method's normal return value and diagnostic properties to determine the outcome.

### Dkim.DkimAlg

`Chilkat 11.7.0 · pascal · Dkim · DkimAlg · property · read/write`

```pascal
property DkimAlg: string read GetDkimAlg write SetDkimAlg;
```

Specifies the signing algorithm written to the `a=` tag of a newly created `DKIM-Signature` header. The default is `rsa-sha256`.

| Value | Behavior |
| :--- | :--- |
| `rsa-sha256` | RSA signing with a SHA-256 digest. This is the recommended value. |
| `rsa-sha1` | Legacy RSA signing with a SHA-1 digest. Use only when an older system specifically requires it. |

The value is trimmed and compared case-insensitively. The recognized values are `rsa-sha256` and `rsa-sha1`. An empty or unrecognized value is normalized to `rsa-sha256` rather than rejected.

### Dkim.DkimBodyLengthCount

`Chilkat 11.7.0 · pascal · Dkim · DkimBodyLengthCount · property · read/write`

```pascal
property DkimBodyLengthCount: Integer read GetDkimBodyLengthCount write SetDkimBodyLengthCount;
```

Controls the maximum number of bytes from the canonicalized message body used when computing the DKIM body hash. The default is `0`.

| Value | Behavior |
| :--- | :--- |
| `0` | Hashes the complete canonicalized body and omits the DKIM `l=` tag. |
| Positive and less than the canonicalized body length | Hashes the specified number of bytes and emits `l=` with that value. |
| Positive and greater than the canonicalized body length | Hashes the complete canonicalized body and emits `l=` containing the actual canonicalized body length. |
| Negative | `-1` hashes the complete canonicalized body and emits `l=` containing the actual canonicalized body length. |

When a generated signature contains `l=`, verification hashes only the indicated prefix of the canonicalized body. Content appended after that signed prefix does not invalidate the signature.

**Security note:** Partial-body signatures allow unsigned content to be appended after the signed portion. Signing the complete body by using `0` is normally preferred.

### Dkim.DkimCanon

`Chilkat 11.7.0 · pascal · Dkim · DkimCanon · property · read/write`

```pascal
property DkimCanon: string read GetDkimCanon write SetDkimCanon;
```

Specifies one DKIM canonicalization algorithm to use for both the signed header fields and the message body. The default is `relaxed`.

| Value | Generated `c=` value | Behavior |
| :--- | :--- | :--- |
| `simple` | `simple/simple` | Preserves formatting closely. Small changes in whitespace or header folding can invalidate the signature. |
| `relaxed` | `relaxed/relaxed` | Normalizes defined whitespace and header-name differences. |

The value is trimmed and compared case-insensitively. This property does not accept a header/body pair such as `relaxed/simple` or `simple/relaxed`. Pair values, an empty string, and other unrecognized values are normalized to `relaxed` rather than rejected.

**Canonicalization background:** DKIM signs a canonicalized representation of the message. The signer and verifier must apply the same header and body canonicalization rules.

### Dkim.DkimDomain

`Chilkat 11.7.0 · pascal · Dkim · DkimDomain · property · read/write`

```pascal
property DkimDomain: string read GetDkimDomain write SetDkimDomain;
```

Specifies the signing domain written verbatim to the `d=` tag of the generated `DKIM-Signature` header. The corresponding public key is normally published beneath the DNS name formed from `DkimSelector` and this domain.

Set this property to a nonempty, syntactically valid domain before calling `DkimSign`. If this property is empty, `DkimSign` returns `False` without modifying the MIME data. A nonempty value is not otherwise validated or normalized during signing; uppercase letters, surrounding whitespace, a trailing dot, and Unicode characters are emitted as supplied.

**Caller responsibility:** Supply the domain in the exact form required in the signature. For an internationalized domain, use its ASCII/Punycode form. `DkimSign` does not check DNS and does not confirm that the configured private key matches the public key published for this domain.

**DKIM and DMARC:** DKIM verification does not require `d=` to equal the visible `From` domain. DMARC separately evaluates alignment between the authenticated DKIM domain and the message's `From` domain.

### Dkim.DkimHeaders

`Chilkat 11.7.0 · pascal · Dkim · DkimHeaders · property · read/write`

```pascal
property DkimHeaders: string read GetDkimHeaders write SetDkimHeaders;
```

A colon-separated list of header field names to include in the DKIM signature. The list is written to the signature's `h=` tag in the same order. The default is:

```
mime-version:date:message-id:subject:from:to:content-type
```

Header-name matching is case-insensitive. For each occurrence of a name in this list, Chilkat selects the next matching header field from the bottom of the message header block upward, as required by DKIM. For example, if the message contains two `Subject` fields, listing `subject` once signs the bottommost field, while listing it twice signs both fields.

If a listed occurrence has no corresponding field in the message, the absent field is still included in the signing calculation. Repeating a name more times than it occurs can therefore implement DKIM oversigning and prevent a matching field from being inserted later without invalidating the signature.

- Use colon-separated field names without surrounding spaces.
- Include `from`; DKIM requires the `From` field to be signed, but `DkimSign` does not enforce this requirement or add it automatically.
- An empty list and names of missing fields are accepted rather than rejected.
- Avoid transport-added or frequently modified fields such as `Received` and `Return-Path`.

**Repeated names:** Repeated existing headers are signed successively from bottom to top. Repeated absent occurrences are useful for oversigning.

### Dkim.DkimSelector

`Chilkat 11.7.0 · pascal · Dkim · DkimSelector · property · read/write`

```pascal
property DkimSelector: string read GetDkimSelector write SetDkimSelector;
```

Specifies the selector written verbatim to the `s=` tag of a generated DKIM signature. The selector and `DkimDomain` form the DNS name used to locate the public key:

```
selector._domainkey.signing-domain
```

For example, selector `brisbane` and domain `chilkatsoft.com` produce `brisbane._domainkey.chilkatsoft.com`.

Supply only the selector. Do not include `._domainkey.` or the signing domain. If this property is empty, `DkimSign` returns `False` without modifying the MIME data. A nonempty value is not otherwise validated or normalized during signing; for example, a complete DNS name is emitted as supplied rather than reduced to a selector.

**Caller responsibility:** Use a nonempty selector consisting of valid DNS selector labels. The private key configured by `SetDkimPrivateKey` must match the public key published for this selector and domain.

### Dkim.HeartbeatMs

`Chilkat 11.7.0 · pascal · Dkim · HeartbeatMs · property · read/write`

```pascal
property HeartbeatMs: Integer read GetHeartbeatMs write SetHeartbeatMs;
```

**Full documentation for this property (same in every language):** [Event Callback Examples](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/event_callback_examples.md)

Specifies the interval, in milliseconds, between `AbortCheck` callbacks during methods that support periodic cancellation checks. Set to `0` to disable these callbacks. The default is `0`.

`PrefetchPublicKey` invokes `AbortCheck` while performing its DNS lookup. Setting this property to `1` and requesting cancellation from the first callback causes `PrefetchPublicKey` to return `False`.

**Responsiveness and overhead:** A smaller interval can make cancellation more responsive, but it also increases callback overhead. Methods that finish quickly may complete before any callback occurs.

### Dkim.VerifyInfo

`Chilkat 11.7.0 · pascal · Dkim · VerifyInfo · property · read-only · since 9.5.0.76`

```pascal
property VerifyInfo: string read GetVerifyInfo;
```

Contains JSON describing the most recent call to `DkimVerify`. The property is initially an empty string and is replaced or cleared by each verification attempt.

| Member | Meaning |
| :--- | :--- |
| `domain` | The signature's `d=` value. |
| `selector` | The signature's `s=` value. |
| `publicKey` | The Base64 public-key value obtained from DNS. This member is present when verification performs an automatic DNS lookup and may be absent when a preloaded or prefetched key is used. |
| `canonicalization` | The header/body canonicalization pair from `c=`. |
| `algorithm` | The signature algorithm from `a=`. |
| `signedHeaders` | The signed-header list from `h=`. |
| `fromSigned` | Indicates whether the required `From` field name is included in the signed-header list. |
| `expectedBodyHash` | The Base64 body hash obtained from the signature's `bh=` tag. |
| `computedBodyHash` | The Base64 body hash computed from the received message, applying the signature's canonicalization and optional `l=` body-length limit. |
| `bodyHashVerified` | The string `"yes"` when the computed body hash matches `bh=`, or `"no"` when it does not. |
| `verified` | The string `"yes"` for a valid signature or `"no"` for a completed verification that failed. |

```
{
  "domain": "chilkatsoft.com",
  "selector": "brisbane",
  "canonicalization": "relaxed/relaxed",
  "algorithm": "rsa-sha256",
  "signedHeaders": "from:to:subject:date:message-id",
  "fromSigned": "yes",
  "expectedBodyHash": "...",
  "computedBodyHash": "...",
  "bodyHashVerified": "yes",
  "verified": "yes"
}
```

Not every member is present in every result. For malformed signatures, unsupported algorithms, missing signatures, DNS failures, or an out-of-range index, the value may be an empty string, `{}`, or a partial object without `verified`. Therefore, first check the return value of `DkimVerify`, and then treat individual JSON members as optional.

**Authentication scope:** A valid DKIM signature shows that the verified signed content was produced by an entity possessing the private key for the authenticated domain. It does not by itself prove the identity of the human sender or establish DMARC alignment.

## Methods

### Dkim.DkimSign

`Chilkat 11.7.0 · pascal · Dkim · DkimSign · method · since 9.5.0.71`

```pascal
// mimeData is a TBinData object.

function  DkimSign(mimeData: TChilkatBase): Boolean;
```

Creates a `DKIM-Signature` header and prepends it to the complete MIME message stored in `mimeData`. The `BinData` is modified in place.

Before calling this method:

- Construct the final MIME message, including all headers, transfer encodings, MIME boundaries, and body bytes.
- Use RFC 5322 line endings. The MIME header and body must use CRLF and be separated by . LF-only and CR-only MIME are not normalized and cause the method to fail.
- Set `DkimDomain`, `DkimSelector`, `DkimAlg`, `DkimCanon`, and `DkimHeaders`.
- Load the RSA private key by calling `SetDkimPrivateKey`.

On success, the generated header contains `v=1`, `a=`, `c=`, `q=dns/txt`, `d=`, `s=`, `h=`, `bh=`, and `b=`. When `DkimBodyLengthCount` is nonzero, the header also contains `l=`. The generated header does not include `t=`, `x=`, or `i=`. Signing the same bytes twice with the same settings and key produced identical output.

An empty body, a body without a final newline, and body data containing NUL or other binary bytes are accepted. An empty `DkimDomain`, an empty `DkimSelector`, missing or invalid private-key state, or malformed MIME causes the method to return `False` without changing `mimeData`.

**Existing signatures:** A new signature is prepended and existing `DKIM-Signature` fields are preserved. Signature indexes therefore follow top-to-bottom order: the newly added signature is index `0`, and older signatures shift to higher indexes. Each signature can be verified independently.

**Sign the final representation:** Send the signed bytes directly. Parsing and regenerating the message, changing line endings, refolding signed headers, changing transfer encodings, or editing the signed body can invalidate the signature.

Returns True for success, False for failure.

### Dkim.DkimVerify

`Chilkat 11.7.0 · pascal · Dkim · DkimVerify · method · since 9.5.0.71`

```pascal
// mimeData is a TBinData object.

function  DkimVerify(sigIndex: Integer;
    mimeData: TChilkatBase): Boolean;
```

Verifies the `DKIM-Signature` header at zero-based `sigIndex` in the complete MIME message stored in `mimeData`. Signatures are indexed in top-to-bottom header order. Use `NumDkimSigs` to obtain the count.

Chilkat first looks for a public key cached under the exact selector/domain strings. If no exact match exists, it synchronously retrieves the TXT record at `selector._domainkey.domain`. The method does not modify `mimeData`.

| Return value | Meaning |
| :--- | :--- |
| `True` | The selected signature was successfully verified, including its body hash and signed headers. |
| `False` | The signature was invalid, or verification could not be completed because of an invalid index, malformed signature, unsupported algorithm, missing key, DNS failure, or another operational error. |

Verification compares the signature's `bh=` value with the hash computed from the canonicalized body. When the signature contains `l=`, only the indicated number of canonicalized body bytes are included, so content appended after the signed prefix does not cause a body-hash failure.

After the call, inspect `VerifyInfo`. A completed verification failure normally contains `"verified":"no"`. A body-hash mismatch also contains `"bodyHashVerified":"no"` with the expected and computed hashes. Operational and parsing failures may leave an empty string, `{}`, or a partial JSON object; use `LastErrorText` for the detailed reason.

**Multiple signatures:** Verify each signature independently. One valid signature does not imply that every signature on the message is valid.

Returns True for success, False for failure.

### Dkim.LoadPublicKey

`Chilkat 11.7.0 · pascal · Dkim · LoadPublicKey · method`

```pascal
function  LoadPublicKey(const selector: string;
    const domain: string;
    const publicKey: string): Boolean;
```

Loads and caches an RSA public key in this `Dkim` object for the exact `selector` and `domain` strings. A later `DkimVerify` uses the cached key when the signature contains the same selector and domain; otherwise verification falls back to DNS.

`publicKey` contains a textual key representation. Supported formats include:

- PEM X.509 SubjectPublicKeyInfo (`-----BEGIN PUBLIC KEY-----`)
- PEM PKCS#1 RSA public key (`-----BEGIN RSA PUBLIC KEY-----`)
- XML RSA key data
- RSA JWK JSON

The selector/domain cache key is case-sensitive. Loading a key for uppercase values does not satisfy a lowercase signature. A successful later load for the same pair replaces the earlier key. If a later load fails because the supplied key text is invalid, the previously cached key remains available.

**Typical use:** Preload a trusted public key for testing before DNS publication or for a controlled verification environment. The key data is copied into the cache; the input string does not need to remain available after this method returns.

Returns True for success, False for failure.

### Dkim.LoadPublicKeyFile

`Chilkat 11.7.0 · pascal · Dkim · LoadPublicKeyFile · method`

```pascal
function  LoadPublicKeyFile(const selector: string;
    const domain: string;
    const publicKeyFilepath: string): Boolean;
```

Loads an RSA public key from the local file at `publicKeyFilepath` and caches it in this `Dkim` object for the exact `selector` and `domain` strings. The file is read during this call.

Supported formats include PEM X.509 SubjectPublicKeyInfo, PEM PKCS#1 RSA public key, binary DER PKCS#1 RSA public key, XML RSA key data, and RSA JWK JSON. The selector/domain cache key is case-sensitive.

A later successful load for the same selector/domain pair replaces the earlier cached key. If no exact cached key is present when `DkimVerify` runs, Chilkat performs its normal DNS lookup.

**Path and trust:** `publicKeyFilepath` is a path in the local filesystem. Load only keys from a trusted source because the cached key determines which signatures are accepted for that selector and domain.

Returns True for success, False for failure.

### Dkim.LoadTaskCaller

`Chilkat 11.7.0 · pascal · Dkim · LoadTaskCaller · method · since 9.5.0.80`

```pascal
// task is a TTask object.

function  LoadTaskCaller(task: TChilkatBase): Boolean;
```

Loads the original caller object associated with the asynchronous `task`. This is an internal support method used by Chilkat's asynchronous task infrastructure and is not normally needed in application code.

Returns True for success, False for failure.

### Dkim.NumDkimSigs

`Chilkat 11.7.0 · pascal · Dkim · NumDkimSigs · method · since 9.5.0.76`

```pascal
// mimeData is a TBinData object.

function  NumDkimSigs(mimeData: TChilkatBase): Integer;
```

Returns the number of header fields named `DKIM-Signature` in `mimeData`. Header-name matching is case-insensitive. The method counts matching fields without validating the signature syntax; for example, a malformed `DKIM-Signature: nonsense` field is still counted.

The indexes used by `DkimVerify` are zero-based and follow top-to-bottom header order. The method returns `0` when no matching header is found, including for an empty message. It does not modify `mimeData`.

**Counting versus validation:** This method is a header count, not a MIME or DKIM validation step. A positive result does not mean that any counted signature is well formed or verifiable.

### Dkim.PrefetchPublicKey

`Chilkat 11.7.0 · pascal · Dkim · PrefetchPublicKey · method`

```pascal
function  PrefetchPublicKey(const selector: string;
    const domain: string): Boolean;
```

Retrieves the DKIM public key from DNS and caches it in this `Dkim` object for the exact `selector` and `domain` strings. The TXT lookup is made for:

```
selector._domainkey.domain
```

The method returns `True` when the DNS lookup and public-key loading succeed. Repeated calls for a cached pair can complete without another observable lookup. A successful prefetch replaces an existing manually loaded key for the same selector/domain pair.

`DkimVerify` also performs this DNS lookup automatically when no exact cached key is available. Prefetching is useful when several messages will be verified for the same selector and domain.

**Cancellation:** This method supports `AbortCheck` callbacks according to `HeartbeatMs`. When the callback requests cancellation, the method returns `False` and the DNS lookup is aborted.

**Key rotation:** The selector identifies a particular published key. When a sender begins using a new selector, prefetch the new selector separately.

Returns True for success, False for failure.

### Dkim.SetDkimPrivateKey

`Chilkat 11.7.0 · pascal · Dkim · SetDkimPrivateKey · method · since 9.5.0.71`

```pascal
// privateKey is a TPrivateKey object.

function  SetDkimPrivateKey(privateKey: TChilkatBase): Boolean;
```

Copies the RSA key from `privateKey` into this object for subsequent calls to `DkimSign`. The source `PrivateKey` object may be destroyed after this method returns successfully, and the configured key can be reused for multiple signatures.

A later successful call replaces the previously configured signing key. A failed call with an empty or unrecognized key clears the usable signing-key state; a subsequent `DkimSign` fails until a valid key is set again.

**Key matching:** The private key must correspond to the public key published at `selector._domainkey.domain`, using `DkimSelector` and `DkimDomain`. This method does not check DNS or confirm the match.

Returns True for success, False for failure.

## Events and callbacks

Chilkat for Pascal supports three synchronous event callbacks: `OnAbortCheck`, `OnPercentDone`, and `OnProgressInfo`. Each is a property of the class; assign a method of one of your own objects (an *of object* handler) to receive the callbacks, or assign `nil` to unhook. The handler types are declared in the `Chilkat.Base` unit:

```pascal
TChilkatAbortCheckEvent   = function(Sender: TChilkatBase): Boolean of object;
TChilkatPercentDoneEvent  = function(Sender: TChilkatBase; PctDone: Integer): Boolean of object;
TChilkatProgressInfoEvent = procedure(Sender: TChilkatBase; const Name, Value: string) of object;
```

All Chilkat methods are synchronous, so callbacks are invoked on the thread that called the method -- if the method was called from the main thread, it is safe to access UI elements from the handler. The `HeartbeatMs` property controls the frequency of `OnAbortCheck` callbacks (the default of 0 means no AbortCheck events fire). Returning `True` from an `OnAbortCheck` or `OnPercentDone` handler aborts the running method.

### Dkim.AbortCheck (event)

`Chilkat 11.7.0 · pascal · Dkim · AbortCheck · event`

```pascal
// TChilkatAbortCheckEvent = function(Sender: TChilkatBase): Boolean of object;

property OnAbortCheck: TChilkatAbortCheckEvent;
```

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.

**Event callback implementation:**

```pascal
// A handler is a method of one of your own classes, e.g. a form:
function TMyObject.DkimAbortCheck(Sender: TChilkatBase): Boolean;
begin
  // Called every HeartbeatMs milliseconds while a method is running.
  // Return True to abort the method; return False to continue.
  Result := False;
end;
```

**To add an event handler:**

```pascal
dkim := TDkim.Create;
dkim.HeartbeatMs := 250;   // fire OnAbortCheck 4 times per second
dkim.OnAbortCheck := MyObject.DkimAbortCheck;
```

### Dkim.PercentDone (event)

`Chilkat 11.7.0 · pascal · Dkim · PercentDone · event`

```pascal
// TChilkatPercentDoneEvent = function(Sender: TChilkatBase; PctDone: Integer): Boolean of object;

property OnPercentDone: TChilkatPercentDoneEvent;
```

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.

**Event callback implementation:**

```pascal
// A handler is a method of one of your own classes, e.g. a form:
function TMyObject.DkimPercentDone(Sender: TChilkatBase; PctDone: Integer): Boolean;
begin
  // PctDone ranges from 1 to 100.
  WriteLn('Percent done: ', PctDone);
  // Return True to abort the method; return False to continue.
  Result := False;
end;
```

**To add an event handler:**

```pascal
dkim := TDkim.Create;
dkim.OnPercentDone := MyObject.DkimPercentDone;
```

### Dkim.ProgressInfo (event)

`Chilkat 11.7.0 · pascal · Dkim · ProgressInfo · event`

```pascal
// TChilkatProgressInfoEvent = procedure(Sender: TChilkatBase; const Name, Value: string) of object;

property OnProgressInfo: TChilkatProgressInfoEvent;
```

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.

**Event callback implementation:**

```pascal
// A handler is a method of one of your own classes, e.g. a form:
procedure TMyObject.DkimProgressInfo(Sender: TChilkatBase; const Name, Value: string);
begin
  WriteLn(Name, ': ', Value);
end;
```

**To add an event handler:**

```pascal
dkim := TDkim.Create;
dkim.OnProgressInfo := MyObject.DkimProgressInfo;
```

## Related classes

[`BinData`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/pascal/classes/BinData.md), [`PrivateKey`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/pascal/classes/PrivateKey.md)