---
product: Chilkat
product_version: 11.7.0
language: delphidll
language_label: Delphi DLL
class: SshTunnel
license: bundle
deprecated: false
reference_html: https://www.chilkatsoft.com/refdoc/dd_CkSshTunnelRef.html
---
# Chilkat SshTunnel — Delphi DLL — v11.7.0

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

## Purpose

**Create SSH tunnels for secure local, fixed-destination, dynamic, and multi-hop forwarding.**

`Chilkat.SshTunnel` creates SSH tunnels for forwarding local client connections through an SSH server to a destination service, such as a database server or other TCP service. It supports fixed destination forwarding, dynamic SOCKS-style port forwarding, password and public-key authentication, keyboard-interactive authentication, proxy connections to the SSH server, multi-hop SSH connections, background accept threads, tunnel/client logging, secure secret lookup, and connection diagnostics.

**Local port forwarding**

Listen on a local port and forward accepted client connections through an SSH server to a configured destination host and port.

**Dynamic forwarding**

Enable SOCKS-style dynamic port forwarding when each client connection should choose its own destination through the tunnel.

**SSH authentication**

Authenticate to the SSH server using passwords, public keys, password-plus-key, secure password lookup, or keyboard-interactive authentication.

**Proxy and multi-hop access**

Reach the SSH server through HTTP or SOCKS proxies, or build tunnels through an existing SSH connection for multi-hop scenarios.

**Accept and manage clients**

Start accepting client connections in the background, inspect current state, stop accepting new clients, and disconnect active tunnel clients.

**Logging and diagnostics**

Use accept logs, tunnel logs, current-state XML, and `LastErrorText` to troubleshoot SSH connection, forwarding, authentication, or client-connection problems.

**Common pattern:** Configure the SSH server, authentication method, local listen settings, and destination forwarding options, then call `BeginAccepting` to start the tunnel. Local client applications connect to the tunnel's listen port, and `SshTunnel` forwards the traffic through SSH. Use `Chilkat.SshTunnel` for port forwarding; use `Chilkat.Ssh` for direct SSH sessions, commands, channels, and shell access.

**Start with the SSH Tunneling Guide**

Learn how static forwarding, dynamic SOCKS forwarding, multi-hop tunneling, proxies, background threads, lifecycle management, and troubleshooting fit together.

[Open the SshTunnel Guide](https://www.chilkatsoft.com/sshtunnel_index.asp)

A shorter API-focused introduction is also available in the [SshTunnel Class Overview](https://www.chilkatsoft.com/sshtunnel_class_overview.asp).

## Object creation, unlocking and error handling

**Create/Dispose**

```pascal
var
myObject: HCkSshTunnel;

begin
myObject := CkSshTunnel_Create();

// ...

CkSshTunnel_Dispose(myObject);
end;
```

`function CkSshTunnel_Create: HCkSshTunnel; stdcall;`

Creates an instance of the HCkSshTunnel 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 CkSshTunnel_Dispose(handle: HCkSshTunnel); stdcall;`

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

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 Delphi DLL.

## 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` | `procedure CkSshTunnel_getDebugLogFilePath(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall; procedure CkSshTunnel_putDebugLogFilePath(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall; function CkSshTunnel__debugLogFilePath(objHandle: HCkSshTunnel): PWideChar; stdcall;` | 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` | `procedure CkSshTunnel_getLastErrorHtml(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall; function CkSshTunnel__lastErrorHtml(objHandle: HCkSshTunnel): PWideChar; stdcall;` | read-only | Provides HTML-formatted information about the last called method or property. |
| `LastErrorText` | `procedure CkSshTunnel_getLastErrorText(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall; function CkSshTunnel__lastErrorText(objHandle: HCkSshTunnel): PWideChar; stdcall;` | read-only | Provides plain text information about the last called method or property. |
| `LastErrorXml` | `procedure CkSshTunnel_getLastErrorXml(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall; function CkSshTunnel__lastErrorXml(objHandle: HCkSshTunnel): PWideChar; stdcall;` | read-only | Provides XML-formatted information about the last called method or property. |
| `LastMethodSuccess` | `function CkSshTunnel_getLastMethodSuccess(objHandle: HCkSshTunnel): wordbool; stdcall; procedure CkSshTunnel_putLastMethodSuccess(objHandle: HCkSshTunnel; newPropVal: wordbool); stdcall;` | read/write | Indicates the success or failure of the most recent method call: `True` means success, `False` means failure. |
| `VerboseLogging` | `function CkSshTunnel_getVerboseLogging(objHandle: HCkSshTunnel): wordbool; stdcall; procedure CkSshTunnel_putVerboseLogging(objHandle: HCkSshTunnel; newPropVal: wordbool); stdcall;` | read/write | If set to `True`, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may contain more verbose information. |
| `Version` | `procedure CkSshTunnel_getVersion(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall; function CkSshTunnel__version(objHandle: HCkSshTunnel): PWideChar; stdcall;` | read-only | Version of the component/library, such as "10.1.0" |

## Member index

| Member | Kind | Signature |
|---|---|---|
| `AbortCurrent` | property, read/write | `function CkSshTunnel_getAbortCurrent(objHandle: HCkSshTunnel): wordbool; stdcall; procedure CkSshTunnel_putAbortCurrent(objHandle: HCkSshTunnel; newPropVal: wordbool); stdcall;` |
| `AcceptLog` | property, read/write | `procedure CkSshTunnel_getAcceptLog(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall; procedure CkSshTunnel_putAcceptLog(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall; function CkSshTunnel__acceptLog(objHandle: HCkSshTunnel): PWideChar; stdcall;` |
| `AcceptLogPath` | property, read/write | `procedure CkSshTunnel_getAcceptLogPath(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall; procedure CkSshTunnel_putAcceptLogPath(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall; function CkSshTunnel__acceptLogPath(objHandle: HCkSshTunnel): PWideChar; stdcall;` |
| `ClientIdentifier` | property, read/write | `procedure CkSshTunnel_getClientIdentifier(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall; procedure CkSshTunnel_putClientIdentifier(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall; function CkSshTunnel__clientIdentifier(objHandle: HCkSshTunnel): PWideChar; stdcall;` |
| `ClientLogDir` | property, read/write | `procedure CkSshTunnel_getClientLogDir(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall; procedure CkSshTunnel_putClientLogDir(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall; function CkSshTunnel__clientLogDir(objHandle: HCkSshTunnel): PWideChar; stdcall;` |
| `ConnectTimeoutMs` | property, read/write | `function CkSshTunnel_getConnectTimeoutMs(objHandle: HCkSshTunnel): Integer; stdcall; procedure CkSshTunnel_putConnectTimeoutMs(objHandle: HCkSshTunnel; newPropVal: Integer); stdcall;` |
| `DestHostname` | property, read/write | `procedure CkSshTunnel_getDestHostname(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall; procedure CkSshTunnel_putDestHostname(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall; function CkSshTunnel__destHostname(objHandle: HCkSshTunnel): PWideChar; stdcall;` |
| `DestPort` | property, read/write | `function CkSshTunnel_getDestPort(objHandle: HCkSshTunnel): Integer; stdcall; procedure CkSshTunnel_putDestPort(objHandle: HCkSshTunnel; newPropVal: Integer); stdcall;` |
| `DynamicPortForwarding` | property, read/write | `function CkSshTunnel_getDynamicPortForwarding(objHandle: HCkSshTunnel): wordbool; stdcall; procedure CkSshTunnel_putDynamicPortForwarding(objHandle: HCkSshTunnel; newPropVal: wordbool); stdcall;` |
| `EnableSecrets` | property, read/write | `function CkSshTunnel_getEnableSecrets(objHandle: HCkSshTunnel): wordbool; stdcall; procedure CkSshTunnel_putEnableSecrets(objHandle: HCkSshTunnel; newPropVal: wordbool); stdcall;` |
| `HostKeyFingerprint` | property, read-only | `procedure CkSshTunnel_getHostKeyFingerprint(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall; function CkSshTunnel__hostKeyFingerprint(objHandle: HCkSshTunnel): PWideChar; stdcall;` |
| `HttpProxyAuthMethod` | property, read/write | `procedure CkSshTunnel_getHttpProxyAuthMethod(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall; procedure CkSshTunnel_putHttpProxyAuthMethod(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall; function CkSshTunnel__httpProxyAuthMethod(objHandle: HCkSshTunnel): PWideChar; stdcall;` |
| `HttpProxyDomain` | property, read/write | `procedure CkSshTunnel_getHttpProxyDomain(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall; procedure CkSshTunnel_putHttpProxyDomain(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall; function CkSshTunnel__httpProxyDomain(objHandle: HCkSshTunnel): PWideChar; stdcall;` |
| `HttpProxyHostname` | property, read/write | `procedure CkSshTunnel_getHttpProxyHostname(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall; procedure CkSshTunnel_putHttpProxyHostname(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall; function CkSshTunnel__httpProxyHostname(objHandle: HCkSshTunnel): PWideChar; stdcall;` |
| `HttpProxyPassword` | property, read/write | `procedure CkSshTunnel_getHttpProxyPassword(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall; procedure CkSshTunnel_putHttpProxyPassword(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall; function CkSshTunnel__httpProxyPassword(objHandle: HCkSshTunnel): PWideChar; stdcall;` |
| `HttpProxyPort` | property, read/write | `function CkSshTunnel_getHttpProxyPort(objHandle: HCkSshTunnel): Integer; stdcall; procedure CkSshTunnel_putHttpProxyPort(objHandle: HCkSshTunnel; newPropVal: Integer); stdcall;` |
| `HttpProxyUsername` | property, read/write | `procedure CkSshTunnel_getHttpProxyUsername(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall; procedure CkSshTunnel_putHttpProxyUsername(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall; function CkSshTunnel__httpProxyUsername(objHandle: HCkSshTunnel): PWideChar; stdcall;` |
| `IdleTimeoutMs` | property, read/write | `function CkSshTunnel_getIdleTimeoutMs(objHandle: HCkSshTunnel): Integer; stdcall; procedure CkSshTunnel_putIdleTimeoutMs(objHandle: HCkSshTunnel; newPropVal: Integer); stdcall;` |
| `InboundSocksPassword` | property, read/write | `procedure CkSshTunnel_getInboundSocksPassword(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall; procedure CkSshTunnel_putInboundSocksPassword(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall; function CkSshTunnel__inboundSocksPassword(objHandle: HCkSshTunnel): PWideChar; stdcall;` |
| `InboundSocksUsername` | property, read/write | `procedure CkSshTunnel_getInboundSocksUsername(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall; procedure CkSshTunnel_putInboundSocksUsername(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall; function CkSshTunnel__inboundSocksUsername(objHandle: HCkSshTunnel): PWideChar; stdcall;` |
| `IsAccepting` | property, read-only | `function CkSshTunnel_getIsAccepting(objHandle: HCkSshTunnel): wordbool; stdcall;` |
| `KeepAcceptLog` | property, read/write | `function CkSshTunnel_getKeepAcceptLog(objHandle: HCkSshTunnel): wordbool; stdcall; procedure CkSshTunnel_putKeepAcceptLog(objHandle: HCkSshTunnel; newPropVal: wordbool); stdcall;` |
| `KeepTunnelLog` | property, read/write | `function CkSshTunnel_getKeepTunnelLog(objHandle: HCkSshTunnel): wordbool; stdcall; procedure CkSshTunnel_putKeepTunnelLog(objHandle: HCkSshTunnel; newPropVal: wordbool); stdcall;` |
| `ListenBindIpAddress` | property, read/write | `procedure CkSshTunnel_getListenBindIpAddress(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall; procedure CkSshTunnel_putListenBindIpAddress(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall; function CkSshTunnel__listenBindIpAddress(objHandle: HCkSshTunnel): PWideChar; stdcall;` |
| `ListenPort` | property, read-only | `function CkSshTunnel_getListenPort(objHandle: HCkSshTunnel): Integer; stdcall;` |
| `OutboundBindIpAddress` | property, read/write | `procedure CkSshTunnel_getOutboundBindIpAddress(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall; procedure CkSshTunnel_putOutboundBindIpAddress(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall; function CkSshTunnel__outboundBindIpAddress(objHandle: HCkSshTunnel): PWideChar; stdcall;` |
| `OutboundBindPort` | property, read/write | `function CkSshTunnel_getOutboundBindPort(objHandle: HCkSshTunnel): Integer; stdcall; procedure CkSshTunnel_putOutboundBindPort(objHandle: HCkSshTunnel; newPropVal: Integer); stdcall;` |
| `PreferIpv6` | property, read/write | `function CkSshTunnel_getPreferIpv6(objHandle: HCkSshTunnel): wordbool; stdcall; procedure CkSshTunnel_putPreferIpv6(objHandle: HCkSshTunnel; newPropVal: wordbool); stdcall;` |
| `SocksHostname` | property, read/write | `procedure CkSshTunnel_getSocksHostname(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall; procedure CkSshTunnel_putSocksHostname(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall; function CkSshTunnel__socksHostname(objHandle: HCkSshTunnel): PWideChar; stdcall;` |
| `SocksPassword` | property, read/write | `procedure CkSshTunnel_getSocksPassword(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall; procedure CkSshTunnel_putSocksPassword(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall; function CkSshTunnel__socksPassword(objHandle: HCkSshTunnel): PWideChar; stdcall;` |
| `SocksPort` | property, read/write | `function CkSshTunnel_getSocksPort(objHandle: HCkSshTunnel): Integer; stdcall; procedure CkSshTunnel_putSocksPort(objHandle: HCkSshTunnel; newPropVal: Integer); stdcall;` |
| `SocksUsername` | property, read/write | `procedure CkSshTunnel_getSocksUsername(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall; procedure CkSshTunnel_putSocksUsername(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall; function CkSshTunnel__socksUsername(objHandle: HCkSshTunnel): PWideChar; stdcall;` |
| `SocksVersion` | property, read/write | `function CkSshTunnel_getSocksVersion(objHandle: HCkSshTunnel): Integer; stdcall; procedure CkSshTunnel_putSocksVersion(objHandle: HCkSshTunnel; newPropVal: Integer); stdcall;` |
| `SoRcvBuf` | property, read/write | `function CkSshTunnel_getSoRcvBuf(objHandle: HCkSshTunnel): Integer; stdcall; procedure CkSshTunnel_putSoRcvBuf(objHandle: HCkSshTunnel; newPropVal: Integer); stdcall;` |
| `SoSndBuf` | property, read/write | `function CkSshTunnel_getSoSndBuf(objHandle: HCkSshTunnel): Integer; stdcall; procedure CkSshTunnel_putSoSndBuf(objHandle: HCkSshTunnel; newPropVal: Integer); stdcall;` |
| `TcpNoDelay` | property, read/write | `function CkSshTunnel_getTcpNoDelay(objHandle: HCkSshTunnel): wordbool; stdcall; procedure CkSshTunnel_putTcpNoDelay(objHandle: HCkSshTunnel; newPropVal: wordbool); stdcall;` |
| `TunnelLog` | property, read/write | `procedure CkSshTunnel_getTunnelLog(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall; procedure CkSshTunnel_putTunnelLog(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall; function CkSshTunnel__tunnelLog(objHandle: HCkSshTunnel): PWideChar; stdcall;` |
| `TunnelLogPath` | property, read/write | `procedure CkSshTunnel_getTunnelLogPath(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall; procedure CkSshTunnel_putTunnelLogPath(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall; function CkSshTunnel__tunnelLogPath(objHandle: HCkSshTunnel): PWideChar; stdcall;` |
| `UncommonOptions` | property, read/write | `procedure CkSshTunnel_getUncommonOptions(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall; procedure CkSshTunnel_putUncommonOptions(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall; function CkSshTunnel__uncommonOptions(objHandle: HCkSshTunnel): PWideChar; stdcall;` |
| `AuthenticatePk` | method | `function CkSshTunnel_AuthenticatePk(objHandle: HCkSshTunnel;     username: PWideChar;     privateKey: HCkSshKey): wordbool; stdcall;` |
| `AuthenticatePw` | method | `function CkSshTunnel_AuthenticatePw(objHandle: HCkSshTunnel;     login: PWideChar;     password: PWideChar): wordbool; stdcall;` |
| `AuthenticatePwPk` | method | `function CkSshTunnel_AuthenticatePwPk(objHandle: HCkSshTunnel;     username: PWideChar;     password: PWideChar;     privateKey: HCkSshKey): wordbool; stdcall;` |
| `AuthenticateSecPw` | method | `function CkSshTunnel_AuthenticateSecPw(objHandle: HCkSshTunnel;     login: HCkSecureString;     password: HCkSecureString): wordbool; stdcall;` |
| `AuthenticateSecPwPk` | method | `function CkSshTunnel_AuthenticateSecPwPk(objHandle: HCkSshTunnel;     username: HCkSecureString;     password: HCkSecureString;     privateKey: HCkSshKey): wordbool; stdcall;` |
| `BeginAccepting` | method | `function CkSshTunnel_BeginAccepting(objHandle: HCkSshTunnel;     listenPort: Integer): wordbool; stdcall;` |
| `CloseTunnel` | method | `function CkSshTunnel_CloseTunnel(objHandle: HCkSshTunnel;     waitForThreads: wordbool): wordbool; stdcall;` |
| `Connect` | method | `function CkSshTunnel_Connect(objHandle: HCkSshTunnel;     hostname: PWideChar;     port: Integer): wordbool; stdcall;` |
| `ConnectThroughSsh` | method | `function CkSshTunnel_ConnectThroughSsh(objHandle: HCkSshTunnel;     ssh: HCkSsh;     hostname: PWideChar;     port: Integer): wordbool; stdcall;` |
| `ContinueKeyboardAuth` | method | `function CkSshTunnel_ContinueKeyboardAuth(objHandle: HCkSshTunnel;     response: PWideChar;     outStr: HCkString): wordbool; stdcall; function CkSshTunnel__continueKeyboardAuth(objHandle: HCkSshTunnel;     response: PWideChar): PWideChar; stdcall;` |
| `DisconnectAllClients` | method | `function CkSshTunnel_DisconnectAllClients(objHandle: HCkSshTunnel;     waitForThreads: wordbool): wordbool; stdcall;` |
| `GetCurrentState` | method | `function CkSshTunnel_GetCurrentState(objHandle: HCkSshTunnel;     outStr: HCkString): wordbool; stdcall; function CkSshTunnel__getCurrentState(objHandle: HCkSshTunnel): PWideChar; stdcall;` |
| `IsSshConnected` | method | `function CkSshTunnel_IsSshConnected(objHandle: HCkSshTunnel): wordbool; stdcall;` |
| `LoadTaskCaller` | method | `function CkSshTunnel_LoadTaskCaller(objHandle: HCkSshTunnel;     task: HCkTask): wordbool; stdcall;` |
| `SetAllowedAlgorithms` | method | `function CkSshTunnel_SetAllowedAlgorithms(objHandle: HCkSshTunnel;     json: HCkJsonObject): wordbool; stdcall;` |
| `StartKeyboardAuth` | method | `function CkSshTunnel_StartKeyboardAuth(objHandle: HCkSshTunnel;     login: PWideChar;     outStr: HCkString): wordbool; stdcall; function CkSshTunnel__startKeyboardAuth(objHandle: HCkSshTunnel;     login: PWideChar): PWideChar; stdcall;` |
| `StopAccepting` | method | `function CkSshTunnel_StopAccepting(objHandle: HCkSshTunnel;     waitForThread: wordbool): wordbool; stdcall;` |

## Properties

### SshTunnel.AbortCurrent

`Chilkat 11.7.0 · delphidll · SshTunnel · AbortCurrent · property · read/write · since 9.5.0.58`

```pascal
function CkSshTunnel_getAbortCurrent(objHandle: HCkSshTunnel): wordbool; stdcall;
procedure CkSshTunnel_putAbortCurrent(objHandle: HCkSshTunnel; newPropVal: wordbool); stdcall;
```

Set this property to `True` from another thread to request that the currently running foreground operation be aborted. For example, it can interrupt a synchronous `Connect` that is waiting for an SSH server response.

This property does not stop the background listener or terminate established background tunnel clients.

Do not assume the property is automatically reset after an operation is aborted. It may remain `True`; set it back to `False` before starting another operation.

### SshTunnel.AcceptLog

`Chilkat 11.7.0 · delphidll · SshTunnel · AcceptLog · property · read/write`

```pascal
procedure CkSshTunnel_getAcceptLog(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall;
procedure CkSshTunnel_putAcceptLog(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall;
function CkSshTunnel__acceptLog(objHandle: HCkSshTunnel): PWideChar; stdcall;
```

Contains the in-memory activity log for the background listener thread started by `BeginAccepting`.

The log is populated only when `KeepAcceptLog` is `True`.

### SshTunnel.AcceptLogPath

`Chilkat 11.7.0 · delphidll · SshTunnel · AcceptLogPath · property · read/write · since 9.5.0.50`

```pascal
procedure CkSshTunnel_getAcceptLogPath(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall;
procedure CkSshTunnel_putAcceptLogPath(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall;
function CkSshTunnel__acceptLogPath(objHandle: HCkSshTunnel): PWideChar; stdcall;
```

Specifies the local file path where activity from the background listener thread is written.

This file-based log is separate from the in-memory `AcceptLog`.

### SshTunnel.ClientIdentifier

`Chilkat 11.7.0 · delphidll · SshTunnel · ClientIdentifier · property · read/write · since 9.5.0.95`

```pascal
procedure CkSshTunnel_getClientIdentifier(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall;
procedure CkSshTunnel_putClientIdentifier(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall;
function CkSshTunnel__clientIdentifier(objHandle: HCkSshTunnel): PWideChar; stdcall;
```

Specifies the SSH client-identification string sent when connecting to the SSH server.

Starting in Chilkat v9.5.0.99, the default is `SSH-2.0-Chilkat_` followed by the Chilkat version number, such as `SSH-2.0-Chilkat_9.5.0.99`.

The identifier should begin with `SSH-2.0-`. Some SSH servers disconnect clients that send an invalid identification string.

### SshTunnel.ClientLogDir

`Chilkat 11.7.0 · delphidll · SshTunnel · ClientLogDir · property · read/write · since 11.1.0`

```pascal
procedure CkSshTunnel_getClientLogDir(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall;
procedure CkSshTunnel_putClientLogDir(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall;
function CkSshTunnel__clientLogDir(objHandle: HCkSshTunnel): PWideChar; stdcall;
```

Specifies the local directory where a separate log file is created for each tunnel client.

When this property is not empty, files are named using the pattern `tunnel_client_log_{random_id}.txt`.

### SshTunnel.ConnectTimeoutMs

`Chilkat 11.7.0 · delphidll · SshTunnel · ConnectTimeoutMs · property · read/write`

```pascal
function CkSshTunnel_getConnectTimeoutMs(objHandle: HCkSshTunnel): Integer; stdcall;
procedure CkSshTunnel_putConnectTimeoutMs(objHandle: HCkSshTunnel; newPropVal: Integer); stdcall;
```

Specifies the maximum number of milliseconds allowed for establishing the SSH connection.

- The default value is `30000` milliseconds (30 seconds).
- A value of `0` disables the connection timeout and allows an unlimited wait.

The timeout applies to more than the initial TCP connection. It also covers connection setup performed through an HTTP or SOCKS proxy and waiting for the SSH server identification string after the TCP connection has been established.

### SshTunnel.DestHostname

`Chilkat 11.7.0 · delphidll · SshTunnel · DestHostname · property · read/write`

```pascal
procedure CkSshTunnel_getDestHostname(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall;
procedure CkSshTunnel_putDestHostname(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall;
function CkSshTunnel__destHostname(objHandle: HCkSshTunnel): PWideChar; stdcall;
```

Specifies the destination hostname or IP address for fixed-destination port forwarding. This is typically the host running the database server or other TCP service that local clients need to reach.

The destination is interpreted from the SSH server's network environment. For example, `localhost` and `127.0.0.1` refer to the SSH server itself, not the computer running the application. Hostname resolution is therefore performed as part of the forwarding request on the SSH-server side.

Traffic accepted by the local listener is carried through SSH, forwarded by the SSH server to this destination, and returned through the same tunnel.

This property is ignored when `DynamicPortForwarding` is `True`. Changing the destination while the listener is running affects new clients only; existing clients remain connected to the destination selected when they were accepted.

### SshTunnel.DestPort

`Chilkat 11.7.0 · delphidll · SshTunnel · DestPort · property · read/write`

```pascal
function CkSshTunnel_getDestPort(objHandle: HCkSshTunnel): Integer; stdcall;
procedure CkSshTunnel_putDestPort(objHandle: HCkSshTunnel; newPropVal: Integer); stdcall;
```

Specifies the TCP port of the destination service used for fixed-destination forwarding, such as the port of a database server.

It is used together with `DestHostname` and is ignored when `DynamicPortForwarding` is `True`.

### SshTunnel.DynamicPortForwarding

`Chilkat 11.7.0 · delphidll · SshTunnel · DynamicPortForwarding · property · read/write · since 9.5.0.50`

```pascal
function CkSshTunnel_getDynamicPortForwarding(objHandle: HCkSshTunnel): wordbool; stdcall;
procedure CkSshTunnel_putDynamicPortForwarding(objHandle: HCkSshTunnel; newPropVal: wordbool); stdcall;
```

Controls whether the listener performs fixed-destination or dynamic port forwarding.

- When `False` (the default), every accepted connection is forwarded to `DestHostname` and `DestPort`.
- When `True`, the listener acts as a SOCKS proxy and each inbound client supplies its own destination.

The SOCKS version is detected independently from each inbound client handshake; there is no separate inbound SOCKS-version property. SOCKS4 and SOCKS5 `CONNECT` requests are supported. SOCKS5 `BIND` and UDP association are not supported.

Leave `InboundSocksUsername` empty to allow SOCKS5 clients to use the no-authentication method. Set the inbound username and password to require SOCKS5 username/password authentication. For SOCKS4, only the user ID can be checked because SOCKS4 has no password field.

SOCKS4a hostname-form requests are not supported. Use a numeric IPv4 address with SOCKS4, or use SOCKS5 when the client needs to supply a domain name.

### SshTunnel.EnableSecrets

`Chilkat 11.7.0 · delphidll · SshTunnel · EnableSecrets · property · read/write · since 11.5.0`

```pascal
function CkSshTunnel_getEnableSecrets(objHandle: HCkSshTunnel): wordbool; stdcall;
procedure CkSshTunnel_putEnableSecrets(objHandle: HCkSshTunnel; newPropVal: wordbool); stdcall;
```

**Full documentation for this property (same in every language):** [More Detailed Information About EnableSecrets](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/secret_specification_strings.md)

Enables automatic resolution of credentials from secure storage provided by the operating system.

When set to `True`, supported password properties and methods may receive a **secret specification string** beginning with `!!` instead of a literal password. Chilkat resolves the secret from:

- Windows Credential Manager on Windows.
- Apple Keychain on macOS.

The specification format is: `!![appName|]service[|domain]|username`

This applies to `HttpProxyPassword`, `SocksPassword`, `AuthenticatePw`, and `AuthenticatePwPk`.

The default value is `False`.

### SshTunnel.HostKeyFingerprint

`Chilkat 11.7.0 · delphidll · SshTunnel · HostKeyFingerprint · property · read-only · since 9.5.0.56`

```pascal
procedure CkSshTunnel_getHostKeyFingerprint(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall;
function CkSshTunnel__hostKeyFingerprint(objHandle: HCkSshTunnel): PWideChar; stdcall;
```

Contains the SSH server host-key fingerprint after `Connect` or `ConnectThroughSsh` establishes the SSH connection. The value is available before user authentication.

Example: `ssh-ed25519 256 e0:33:b1:81:a5:c6:9a:d2:2e:c9:d3:15:60:ea:cf:4c`

Compare this value with a trusted expected fingerprint to verify the identity of the SSH server. For `ConnectThroughSsh`, the fingerprint is for the final SSH server, not the first-hop server.

The value may remain populated after `CloseTunnel` or after the connection is lost. Use `IsSshConnected` to determine current connection state.

### SshTunnel.HttpProxyAuthMethod

`Chilkat 11.7.0 · delphidll · SshTunnel · HttpProxyAuthMethod · property · read/write`

```pascal
procedure CkSshTunnel_getHttpProxyAuthMethod(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall;
procedure CkSshTunnel_putHttpProxyAuthMethod(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall;
function CkSshTunnel__httpProxyAuthMethod(objHandle: HCkSshTunnel): PWideChar; stdcall;
```

Specifies the authentication method to use when the outbound connection to the SSH server passes through an HTTP proxy that requires authentication.

Valid values are `Basic` and `NTLM`.

If `SocksVersion` is set to `4` or `5`, the SOCKS proxy takes precedence and these HTTP proxy settings are ignored. The proxies are not chained.

### SshTunnel.HttpProxyDomain

`Chilkat 11.7.0 · delphidll · SshTunnel · HttpProxyDomain · property · read/write`

```pascal
procedure CkSshTunnel_getHttpProxyDomain(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall;
procedure CkSshTunnel_putHttpProxyDomain(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall;
function CkSshTunnel__httpProxyDomain(objHandle: HCkSshTunnel): PWideChar; stdcall;
```

Specifies the optional Windows domain used for NTLM authentication with the HTTP proxy.

This applies only to the outbound proxy connection used to reach the SSH server, and only when `HttpProxyAuthMethod` is `NTLM`.

If `SocksVersion` is set to `4` or `5`, the SOCKS proxy takes precedence and these HTTP proxy settings are ignored. The proxies are not chained.

### SshTunnel.HttpProxyHostname

`Chilkat 11.7.0 · delphidll · SshTunnel · HttpProxyHostname · property · read/write`

```pascal
procedure CkSshTunnel_getHttpProxyHostname(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall;
procedure CkSshTunnel_putHttpProxyHostname(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall;
function CkSshTunnel__httpProxyHostname(objHandle: HCkSshTunnel): PWideChar; stdcall;
```

Specifies the hostname or IPv4 address of the HTTP proxy through which the outbound connection to the SSH server is made.

Leave this property empty when no HTTP proxy is required.

If `SocksVersion` is set to `4` or `5`, the SOCKS proxy takes precedence and these HTTP proxy settings are ignored. The proxies are not chained.

### SshTunnel.HttpProxyPassword

`Chilkat 11.7.0 · delphidll · SshTunnel · HttpProxyPassword · property · read/write`

```pascal
procedure CkSshTunnel_getHttpProxyPassword(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall;
procedure CkSshTunnel_putHttpProxyPassword(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall;
function CkSshTunnel__httpProxyPassword(objHandle: HCkSshTunnel): PWideChar; stdcall;
```

Specifies the password used to authenticate with the HTTP proxy for the outbound connection to the SSH server.

If `SocksVersion` is set to `4` or `5`, the SOCKS proxy takes precedence and these HTTP proxy settings are ignored. The proxies are not chained.

### SshTunnel.HttpProxyPort

`Chilkat 11.7.0 · delphidll · SshTunnel · HttpProxyPort · property · read/write`

```pascal
function CkSshTunnel_getHttpProxyPort(objHandle: HCkSshTunnel): Integer; stdcall;
procedure CkSshTunnel_putHttpProxyPort(objHandle: HCkSshTunnel; newPropVal: Integer); stdcall;
```

Specifies the TCP port of the HTTP proxy used for the outbound connection to the SSH server.

Common HTTP proxy ports include `8080` and `3128`.

If `SocksVersion` is set to `4` or `5`, the SOCKS proxy takes precedence and these HTTP proxy settings are ignored. The proxies are not chained.

### SshTunnel.HttpProxyUsername

`Chilkat 11.7.0 · delphidll · SshTunnel · HttpProxyUsername · property · read/write`

```pascal
procedure CkSshTunnel_getHttpProxyUsername(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall;
procedure CkSshTunnel_putHttpProxyUsername(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall;
function CkSshTunnel__httpProxyUsername(objHandle: HCkSshTunnel): PWideChar; stdcall;
```

Specifies the username used to authenticate with the HTTP proxy for the outbound connection to the SSH server.

If `SocksVersion` is set to `4` or `5`, the SOCKS proxy takes precedence and these HTTP proxy settings are ignored. The proxies are not chained.

### SshTunnel.IdleTimeoutMs

`Chilkat 11.7.0 · delphidll · SshTunnel · IdleTimeoutMs · property · read/write`

```pascal
function CkSshTunnel_getIdleTimeoutMs(objHandle: HCkSshTunnel): Integer; stdcall;
procedure CkSshTunnel_putIdleTimeoutMs(objHandle: HCkSshTunnel; newPropVal: Integer); stdcall;
```

Specifies a stall timeout, in milliseconds, for tunnel data-transfer operations. The default value is `30000` milliseconds (30 seconds). A value of `0` disables the timeout.

This property is not a general inactivity timer for established background tunnel clients. An otherwise idle client, or a client with data queued while an SSH channel is flow-controlled, may remain connected beyond this interval. Applications should not rely on this property to disconnect clients merely because no application data is flowing.

### SshTunnel.InboundSocksPassword

`Chilkat 11.7.0 · delphidll · SshTunnel · InboundSocksPassword · property · read/write · since 9.5.0.50`

```pascal
procedure CkSshTunnel_getInboundSocksPassword(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall;
procedure CkSshTunnel_putInboundSocksPassword(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall;
function CkSshTunnel__inboundSocksPassword(objHandle: HCkSshTunnel): PWideChar; stdcall;
```

Specifies the password required from inbound SOCKS5 clients when `DynamicPortForwarding` is `True`.

This property is used together with `InboundSocksUsername`. It does not apply to SOCKS4 because the SOCKS4 protocol has no password field.

### SshTunnel.InboundSocksUsername

`Chilkat 11.7.0 · delphidll · SshTunnel · InboundSocksUsername · property · read/write · since 9.5.0.50`

```pascal
procedure CkSshTunnel_getInboundSocksUsername(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall;
procedure CkSshTunnel_putInboundSocksUsername(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall;
function CkSshTunnel__inboundSocksUsername(objHandle: HCkSshTunnel): PWideChar; stdcall;
```

Specifies the username required from inbound SOCKS clients when `DynamicPortForwarding` is `True`.

- For SOCKS5, setting this property enables username/password authentication.
- For SOCKS4, the value is compared with the client-supplied user ID.
- Leave it empty to require no inbound SOCKS username.

### SshTunnel.IsAccepting

`Chilkat 11.7.0 · delphidll · SshTunnel · IsAccepting · property · read-only`

```pascal
function CkSshTunnel_getIsAccepting(objHandle: HCkSshTunnel): wordbool; stdcall;
```

`True` when the local listener thread is running and accepting inbound TCP connections; otherwise `False`.

This property describes only the local listener. It can remain `True` after the SSH connection is lost or after `CloseTunnel` is called. In those states a client may connect to the local port even though its traffic cannot be forwarded.

Use `IsSshConnected` separately when the application also needs to know whether the SSH transport is available.

### SshTunnel.KeepAcceptLog

`Chilkat 11.7.0 · delphidll · SshTunnel · KeepAcceptLog · property · read/write`

```pascal
function CkSshTunnel_getKeepAcceptLog(objHandle: HCkSshTunnel): wordbool; stdcall;
procedure CkSshTunnel_putKeepAcceptLog(objHandle: HCkSshTunnel; newPropVal: wordbool); stdcall;
```

Controls whether activity from the background listener thread is retained in memory.

The default value is `False`. When enabled, retrieve the log from `AcceptLog`.

### SshTunnel.KeepTunnelLog

`Chilkat 11.7.0 · delphidll · SshTunnel · KeepTunnelLog · property · read/write · since 9.5.0.50`

```pascal
function CkSshTunnel_getKeepTunnelLog(objHandle: HCkSshTunnel): wordbool; stdcall;
procedure CkSshTunnel_putKeepTunnelLog(objHandle: HCkSshTunnel; newPropVal: wordbool); stdcall;
```

Controls whether SSH tunnel-thread activity is retained in memory.

The default value is `False`. When enabled, retrieve the log from `TunnelLog`.

### SshTunnel.ListenBindIpAddress

`Chilkat 11.7.0 · delphidll · SshTunnel · ListenBindIpAddress · property · read/write`

```pascal
procedure CkSshTunnel_getListenBindIpAddress(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall;
procedure CkSshTunnel_putListenBindIpAddress(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall;
function CkSshTunnel__listenBindIpAddress(objHandle: HCkSshTunnel): PWideChar; stdcall;
```

Specifies the local IPv4 address to which the tunnel's listening socket is bound.

| Value | Listener exposure |
| :--- | :--- |
| Empty string | Binds to `0.0.0.0` and accepts connections on all local IPv4 interfaces, subject to firewall rules. |
| `127.0.0.1` | Accepts connections only from the local computer through loopback. |
| A specific local LAN address | Accepts connections through that interface only; loopback is not included automatically. |

For a tunnel intended only for local applications, explicitly set this property to `127.0.0.1`. Leaving it empty may expose the listening port to other computers on the network.

If the value is malformed or is not assigned to a local interface, `BeginAccepting` returns `False` and the bind failure is available in `LastErrorText` and the accept log.

### SshTunnel.ListenPort

`Chilkat 11.7.0 · delphidll · SshTunnel · ListenPort · property · read-only`

```pascal
function CkSshTunnel_getListenPort(objHandle: HCkSshTunnel): Integer; stdcall;
```

Contains the local TCP port used by the listener started by `BeginAccepting`.

- If `BeginAccepting` succeeds with a nonzero requested port, this property contains that port.
- If `BeginAccepting` succeeds with `0`, the operating system chooses an available port and this property contains the allocated port when the method returns.
- After a bind failure for an explicitly requested port, this property may still contain the requested port even though `IsAccepting` is `False`.
- The value is initially `0`.

### SshTunnel.OutboundBindIpAddress

`Chilkat 11.7.0 · delphidll · SshTunnel · OutboundBindIpAddress · property · read/write`

```pascal
procedure CkSshTunnel_getOutboundBindIpAddress(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall;
procedure CkSshTunnel_putOutboundBindIpAddress(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall;
function CkSshTunnel__outboundBindIpAddress(objHandle: HCkSshTunnel): PWideChar; stdcall;
```

Specifies the local IP address to which the outbound socket is bound before connecting to the SSH server.

Most applications should leave this property empty. Set it only on a multihomed computer when the SSH connection must originate from a specific local network interface or IP address.

### SshTunnel.OutboundBindPort

`Chilkat 11.7.0 · delphidll · SshTunnel · OutboundBindPort · property · read/write`

```pascal
function CkSshTunnel_getOutboundBindPort(objHandle: HCkSshTunnel): Integer; stdcall;
procedure CkSshTunnel_putOutboundBindPort(objHandle: HCkSshTunnel; newPropVal: Integer); stdcall;
```

Specifies the local TCP port to bind before making the outbound connection to the SSH server.

The default value is `0`, which allows the operating system to choose an available ephemeral port. Nearly all applications should leave this property unchanged.

### SshTunnel.PreferIpv6

`Chilkat 11.7.0 · delphidll · SshTunnel · PreferIpv6 · property · read/write · since 9.5.0.70`

```pascal
function CkSshTunnel_getPreferIpv6(objHandle: HCkSshTunnel): wordbool; stdcall;
procedure CkSshTunnel_putPreferIpv6(objHandle: HCkSshTunnel; newPropVal: wordbool); stdcall;
```

Controls which IP version is preferred when a hostname resolves to both IPv4 and IPv6 addresses.

- `False` (the default) prefers IPv4.
- `True` prefers IPv6.

### SshTunnel.SocksHostname

`Chilkat 11.7.0 · delphidll · SshTunnel · SocksHostname · property · read/write`

```pascal
procedure CkSshTunnel_getSocksHostname(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall;
procedure CkSshTunnel_putSocksHostname(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall;
function CkSshTunnel__socksHostname(objHandle: HCkSshTunnel): PWideChar; stdcall;
```

Specifies the hostname or IPv4 address of the outbound SOCKS4 or SOCKS5 proxy used to reach the SSH server.

This property is used only when `SocksVersion` is `4` or `5`.

### SshTunnel.SocksPassword

`Chilkat 11.7.0 · delphidll · SshTunnel · SocksPassword · property · read/write`

```pascal
procedure CkSshTunnel_getSocksPassword(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall;
procedure CkSshTunnel_putSocksPassword(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall;
function CkSshTunnel__socksPassword(objHandle: HCkSshTunnel): PWideChar; stdcall;
```

Specifies the password for authenticating with an outbound SOCKS5 proxy used to reach the SSH server.

SOCKS4 does not support password authentication, so this property does not apply when `SocksVersion` is `4`.

### SshTunnel.SocksPort

`Chilkat 11.7.0 · delphidll · SshTunnel · SocksPort · property · read/write`

```pascal
function CkSshTunnel_getSocksPort(objHandle: HCkSshTunnel): Integer; stdcall;
procedure CkSshTunnel_putSocksPort(objHandle: HCkSshTunnel; newPropVal: Integer); stdcall;
```

Specifies the TCP port of the outbound SOCKS4 or SOCKS5 proxy used to reach the SSH server.

The default value is `1080`. This property is used only when `SocksVersion` is `4` or `5`.

### SshTunnel.SocksUsername

`Chilkat 11.7.0 · delphidll · SshTunnel · SocksUsername · property · read/write`

```pascal
procedure CkSshTunnel_getSocksUsername(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall;
procedure CkSshTunnel_putSocksUsername(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall;
function CkSshTunnel__socksUsername(objHandle: HCkSshTunnel): PWideChar; stdcall;
```

Specifies the username for the outbound SOCKS4 or SOCKS5 proxy used to reach the SSH server.

This property is used only when `SocksVersion` is `4` or `5`.

### SshTunnel.SocksVersion

`Chilkat 11.7.0 · delphidll · SshTunnel · SocksVersion · property · read/write`

```pascal
function CkSshTunnel_getSocksVersion(objHandle: HCkSshTunnel): Integer; stdcall;
procedure CkSshTunnel_putSocksVersion(objHandle: HCkSshTunnel; newPropVal: Integer); stdcall;
```

Selects whether the outbound connection to the SSH server is made through a SOCKS proxy.

| Value | Behavior |
| :--- | :--- |
| `0` | Do not use a SOCKS proxy. This is the default. |
| `4` | Connect through a SOCKS4 proxy. |
| `5` | Connect through a SOCKS5 proxy. |

When this property is `4` or `5`, the SOCKS proxy settings take precedence over the HTTP proxy settings. The SOCKS and HTTP proxies are not chained.

### SshTunnel.SoRcvBuf

`Chilkat 11.7.0 · delphidll · SshTunnel · SoRcvBuf · property · read/write`

```pascal
function CkSshTunnel_getSoRcvBuf(objHandle: HCkSshTunnel): Integer; stdcall;
procedure CkSshTunnel_putSoRcvBuf(objHandle: HCkSshTunnel; newPropVal: Integer); stdcall;
```

Sets the receive-buffer size for the underlying TCP socket.

The default value is `4194304` bytes. Normally this property should remain unchanged. If receive performance is unusually slow, testing a larger value that is a multiple of `4096` may help.

See also:

- [More Information about TCP performance and Buffer Sizes](http://www.cknotes.com/?p=446)

### SshTunnel.SoSndBuf

`Chilkat 11.7.0 · delphidll · SshTunnel · SoSndBuf · property · read/write`

```pascal
function CkSshTunnel_getSoSndBuf(objHandle: HCkSshTunnel): Integer; stdcall;
procedure CkSshTunnel_putSoSndBuf(objHandle: HCkSshTunnel; newPropVal: Integer); stdcall;
```

Sets the send-buffer size for the underlying TCP socket.

The default value is `262144` bytes. Normally this property should remain unchanged. If send performance is unusually slow, testing values such as `524288` or `1048576` may help. A multiple of `4096` is recommended.

See also:

- [More Information about TCP performance and Buffer Sizes](http://www.cknotes.com/?p=446)

### SshTunnel.TcpNoDelay

`Chilkat 11.7.0 · delphidll · SshTunnel · TcpNoDelay · property · read/write`

```pascal
function CkSshTunnel_getTcpNoDelay(objHandle: HCkSshTunnel): wordbool; stdcall;
procedure CkSshTunnel_putTcpNoDelay(objHandle: HCkSshTunnel; newPropVal: wordbool); stdcall;
```

Controls the `TCP_NODELAY` socket option for the underlying TCP connection.

The default value is `False`. Setting it to `True` disables the Nagle algorithm, which can reduce latency when many small amounts of data are sent.

### SshTunnel.TunnelLog

`Chilkat 11.7.0 · delphidll · SshTunnel · TunnelLog · property · read/write · since 9.5.0.50`

```pascal
procedure CkSshTunnel_getTunnelLog(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall;
procedure CkSshTunnel_putTunnelLog(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall;
function CkSshTunnel__tunnelLog(objHandle: HCkSshTunnel): PWideChar; stdcall;
```

Contains the in-memory activity log for the SSH tunnel and client-manager threads. The log is populated only when `KeepTunnelLog` is `True`.

Treat this log as sensitive diagnostic data. It can contain hostnames, ports, usernames, proxy details, SOCKS handshake information, and authentication failure values. Do not publish or persist it without reviewing and protecting its contents.

### SshTunnel.TunnelLogPath

`Chilkat 11.7.0 · delphidll · SshTunnel · TunnelLogPath · property · read/write · since 9.5.0.50`

```pascal
procedure CkSshTunnel_getTunnelLogPath(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall;
procedure CkSshTunnel_putTunnelLogPath(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall;
function CkSshTunnel__tunnelLogPath(objHandle: HCkSshTunnel): PWideChar; stdcall;
```

Specifies the local file path where SSH tunnel-thread activity is written.

This file-based log is separate from the in-memory `TunnelLog`.

### SshTunnel.UncommonOptions

`Chilkat 11.7.0 · delphidll · SshTunnel · UncommonOptions · property · read/write · since 9.5.0.73`

```pascal
procedure CkSshTunnel_getUncommonOptions(objHandle: HCkSshTunnel; outPropVal: HCkString); stdcall;
procedure CkSshTunnel_putUncommonOptions(objHandle: HCkSshTunnel; newPropVal: PWideChar); stdcall;
function CkSshTunnel__uncommonOptions(objHandle: HCkSshTunnel): PWideChar; stdcall;
```

Provides optional behavior for uncommon requirements. The default value is an empty string, which is appropriate for most applications.

To enable more than one option, provide a comma-separated list of keywords.

| Keyword | Effect |
| :--- | :--- |
| `ForceUserAuthRsaSha1` | Forces `rsa-sha1` for public-key user authentication. Set this before connecting. Added in v9.5.0.98. |
| `NoKeepAliveIgnoreMsg` | Disables the default SSH `ignore` message sent every 20 seconds to keep an idle connection alive. Added in v9.5.0.76. |
| `no-weak-mac-algs` | Removes `hmac-sha1-96`, `hmac-sha1`, `hmac-md5`, and `hmac-ripemd160` from the offered MAC algorithms. Added in v9.5.0.98. |
| `ProtectFromVpn` | On Android, bypasses an installed or active VPN. Added in v9.5.0.80. |
| `+ssh-hmac-etm` | Re-enables SSH encrypt-then-MAC algorithms that were disabled by default in v9.5.0.97 as part of the Terrapin mitigation. |
| `+chacha20-poly1305@openssh.com` | Re-enables `chacha20-poly1305@openssh.com`, which was removed from the default offer in v9.5.0.97 as part of the Terrapin mitigation. |

## Methods

### SshTunnel.AuthenticatePk

`Chilkat 11.7.0 · delphidll · SshTunnel · AuthenticatePk · method · since 9.5.0.50`

```pascal
function CkSshTunnel_AuthenticatePk(objHandle: HCkSshTunnel;
    username: PWideChar;
    privateKey: HCkSshKey): wordbool; stdcall;
```

Authenticates with the SSH server using public-key authentication.

The public key corresponding to `privateKey` must already be installed for `username` on the SSH server.

Call `Connect` or `ConnectThroughSsh` before calling this method.

When requesting support for an authentication failure, include the complete `LastErrorText`.

Returns True for success, False for failure.

Async variant: `AuthenticatePkAsync` — same arguments, returns a `Task` (see Async variants below).

See also:

- [Beware of too much time between connect and authentication.](http://www.cknotes.com/?p=278)

### SshTunnel.AuthenticatePw

`Chilkat 11.7.0 · delphidll · SshTunnel · AuthenticatePw · method · since 9.5.0.50`

```pascal
function CkSshTunnel_AuthenticatePw(objHandle: HCkSshTunnel;
    login: PWideChar;
    password: PWideChar): wordbool; stdcall;
```

Authenticates with the SSH server using `login` and `password`.

Establish the SSH connection first by calling `Connect` or `ConnectThroughSsh`. After authentication succeeds, call `BeginAccepting` to begin accepting tunnel clients.

- A rejected username or password does not close the SSH connection; the application may correct the credentials and call this method again.
- Calling this method again after authentication has already succeeded returns `False` with an “Already authenticated” error.

When requesting support for an authentication failure, include the complete `LastErrorText` captured immediately after the failed call.

Returns True for success, False for failure.

Async variant: `AuthenticatePwAsync` — same arguments, returns a `Task` (see Async variants below).

See also:

- [Beware of too much time between connect and authentication.](http://www.cknotes.com/?p=278)

### SshTunnel.AuthenticatePwPk

`Chilkat 11.7.0 · delphidll · SshTunnel · AuthenticatePwPk · method · since 9.5.0.50`

```pascal
function CkSshTunnel_AuthenticatePwPk(objHandle: HCkSshTunnel;
    username: PWideChar;
    password: PWideChar;
    privateKey: HCkSshKey): wordbool; stdcall;
```

Authenticates with an SSH server that requires both a password and a private key.

The public key corresponding to `privateKey` must already be installed for `username` on the SSH server. Most SSH servers require either password authentication or public-key authentication rather than both.

When requesting support for an authentication failure, include the complete `LastErrorText`.

Returns True for success, False for failure.

Async variant: `AuthenticatePwPkAsync` — same arguments, returns a `Task` (see Async variants below).

### SshTunnel.AuthenticateSecPw

`Chilkat 11.7.0 · delphidll · SshTunnel · AuthenticateSecPw · method · since 9.5.0.71`

```pascal
function CkSshTunnel_AuthenticateSecPw(objHandle: HCkSshTunnel;
    login: HCkSecureString;
    password: HCkSecureString): wordbool; stdcall;
```

Performs the same password authentication as `AuthenticatePw`, but receives the login and password in `SecureString` objects.

Returns True for success, False for failure.

Async variant: `AuthenticateSecPwAsync` — same arguments, returns a `Task` (see Async variants below).

### SshTunnel.AuthenticateSecPwPk

`Chilkat 11.7.0 · delphidll · SshTunnel · AuthenticateSecPwPk · method · since 9.5.0.71`

```pascal
function CkSshTunnel_AuthenticateSecPwPk(objHandle: HCkSshTunnel;
    username: HCkSecureString;
    password: HCkSecureString;
    privateKey: HCkSshKey): wordbool; stdcall;
```

Performs the same combined password-and-private-key authentication as `AuthenticatePwPk`, but receives the username and password in `SecureString` objects.

Returns True for success, False for failure.

Async variant: `AuthenticateSecPwPkAsync` — same arguments, returns a `Task` (see Async variants below).

### SshTunnel.BeginAccepting

`Chilkat 11.7.0 · delphidll · SshTunnel · BeginAccepting · method`

```pascal
function CkSshTunnel_BeginAccepting(objHandle: HCkSshTunnel;
    listenPort: Integer): wordbool; stdcall;
```

Creates and starts the local listener on `listenPort`.

The SSH connection must already have been established. Although the listener can be started before user authentication, clients accepted in that state cannot be forwarded. The recommended sequence is to connect, authenticate, and then call this method.

- The requested port must not already be in use on the selected local interface.
- Pass `0` to let the operating system choose an available port, then read `ListenPort`.
- Calling this method while the listener is already running returns `False`.

The method waits for the initial bind-and-listen result. It returns `False` for errors such as an occupied port, a malformed bind address, or an address that is not assigned to the local computer. Details are available immediately in `LastErrorText` and, when enabled, the accept log.

A successful return means the listener was bound and started. No additional fixed delay is required merely to discover an initial bind failure.

Returns True for success, False for failure.

Async variant: `BeginAcceptingAsync` — same arguments, returns a `Task` (see Async variants below).

### SshTunnel.CloseTunnel

`Chilkat 11.7.0 · delphidll · SshTunnel · CloseTunnel · method · since 9.5.0.50`

```pascal
function CkSshTunnel_CloseTunnel(objHandle: HCkSshTunnel;
    waitForThreads: wordbool): wordbool; stdcall;
```

Disconnects active tunnel clients and stops the tunnel-manager thread.

When `waitForThreads` is `True`, the method waits for the client and tunnel-manager threads to exit. It returns `False` if a worker thread does not stop; capture `LastErrorText` immediately for details.

This method does not stop the local listener and does not disconnect or reset the underlying SSH transport. Call `StopAccepting` separately to stop accepting local TCP connections. After this method returns, the listener may still accept a local connection even though the connection cannot be forwarded.

Calling this method more than once is allowed. However, it does not reset the object for a new call to `Connect`. Use a new `SshTunnel` object when connecting to a different SSH server.

Returns True for success, False for failure.

### SshTunnel.Connect

`Chilkat 11.7.0 · delphidll · SshTunnel · Connect · method · since 9.5.0.50`

```pascal
function CkSshTunnel_Connect(objHandle: HCkSshTunnel;
    hostname: PWideChar;
    port: Integer): wordbool; stdcall;
```

Establishes the SSH connection that will carry tunneled traffic. This method performs the TCP or proxy connection, the SSH protocol handshake, and host-key negotiation, but it does not authenticate the SSH user.

After connecting, verify `HostKeyFingerprint`, then authenticate by calling one of the `Authenticate*` methods. Finally, call `BeginAccepting` to start the local listener.

The host-key fingerprint is available immediately after this method succeeds, before user authentication. Calling `Connect` again while an SSH tunnel already exists returns `False`.

Chilkat sends an SSH `ignore` message every 20 seconds to help keep an unused SSH connection alive. To disable this behavior, add `NoKeepAliveIgnoreMsg` to `UncommonOptions` before connecting.

Returns True for success, False for failure.

Async variant: `ConnectAsync` — same arguments, returns a `Task` (see Async variants below).

### SshTunnel.ConnectThroughSsh

`Chilkat 11.7.0 · delphidll · SshTunnel · ConnectThroughSsh · method · since 9.5.0.55`

```pascal
function CkSshTunnel_ConnectThroughSsh(objHandle: HCkSshTunnel;
    ssh: HCkSsh;
    hostname: PWideChar;
    port: Integer): wordbool; stdcall;
```

Connects to a second SSH server through the existing connected and authenticated `Ssh` object supplied in `ssh`.

```
application -> first SSH server -> second SSH server
```

`hostname` and `port` identify the second SSH server. After this method succeeds, call an authentication method on this `SshTunnel` object to authenticate with the second server.

The supplied `Ssh` object is borrowed, not copied. It must remain alive, connected, and authenticated for as long as this tunnel is used. If the first-hop object is disconnected, existing forwarded clients stop working and new local connections cannot be forwarded. The local listener may nevertheless remain active until explicitly stopped.

`HostKeyFingerprint` reports the fingerprint of the second SSH server. After the connection is established, fixed forwarding destinations such as `127.0.0.1` are interpreted from the second server's network environment.

Returns True for success, False for failure.

Async variant: `ConnectThroughSshAsync` — same arguments, returns a `Task` (see Async variants below).

### SshTunnel.ContinueKeyboardAuth

`Chilkat 11.7.0 · delphidll · SshTunnel · ContinueKeyboardAuth · method · since 9.5.0.78`

```pascal
function CkSshTunnel_ContinueKeyboardAuth(objHandle: HCkSshTunnel;
    response: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkSshTunnel__continueKeyboardAuth(objHandle: HCkSshTunnel;
    response: PWideChar): PWideChar; stdcall;
```

Continues a keyboard-interactive authentication exchange started by `StartKeyboardAuth`.

If the server requested one response, pass that value directly in `response`. If it requested multiple responses, pass XML in the following form:

```
<response>
  <response1>response to first prompt</response1>
  <response2>response to second prompt</response2>
  ...
  <responseN>response to Nth prompt</responseN>
</response>
```

When authentication completes, the returned XML indicates success or failure:

```
<success>success message</success>

<error>error message</error>
```

If another challenge is required, the method returns another `infoRequest` XML document containing the next set of prompts.

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

Async variant: `ContinueKeyboardAuthAsync` — same arguments, returns a `Task` (see Async variants below).

### SshTunnel.DisconnectAllClients

`Chilkat 11.7.0 · delphidll · SshTunnel · DisconnectAllClients · method · since 9.5.0.50`

```pascal
function CkSshTunnel_DisconnectAllClients(objHandle: HCkSshTunnel;
    waitForThreads: wordbool): wordbool; stdcall;
```

Disconnects all active tunnel clients while leaving the local listener and SSH connection available.

When `waitForThreads` is `True`, the method waits for the current client threads to exit before returning. The listener continues accepting new clients, and newly accepted clients can be forwarded normally.

Returns True for success, False for failure.

### SshTunnel.GetCurrentState

`Chilkat 11.7.0 · delphidll · SshTunnel · GetCurrentState · method · since 9.5.0.65`

```pascal
function CkSshTunnel_GetCurrentState(objHandle: HCkSshTunnel;
    outStr: HCkString): wordbool; stdcall;
function CkSshTunnel__getCurrentState(objHandle: HCkSshTunnel): PWideChar; stdcall;
```

Returns an XML snapshot describing the tunnel manager, SSH channels, and current tunnel clients. The returned data is intended for diagnostics and monitoring.

A typical result has the following structure:

```
<CurrentState>
  <tunnelManager rcvByteCount="433" sndByteCount="34"
      threadRunning="1" dynamicPortForwarding="0"
      staticDestHost="localhost" staticDestPort="18080">
    <openChannels count="1">
      <channel num="101" channelType="direct-tcpip"
          clientWinSize="2096927" serverWinSize="2097127" />
    </openChannels>
    <closedChannels count="0" />
  </tunnelManager>
  <clients count="1">
    <client destIp="localhost" destPort="18080"
        sshChannelNum="101" threadRunning="1"
        rcvByteCount="25" sndByteCount="225" />
  </clients>
</CurrentState>
```

The exact child elements can vary with state. For example, channel collections may be empty, and some transport details may be omitted before the tunnel is started or after it stops.

| Section | Information |
| :--- | :--- |
| `tunnelManager` | Aggregate byte counts, worker-thread state, forwarding mode, and configured fixed destination. |
| `openChannels` and `closedChannels` | SSH channel numbers, close/EOF flags, packet sizes, and flow-control window sizes. |
| `clients` | Per-client destination, SSH channel number, worker state, age/activity counters, pending-data flags, and byte counts. |

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

### SshTunnel.IsSshConnected

`Chilkat 11.7.0 · delphidll · SshTunnel · IsSshConnected · method · since 9.5.0.61`

```pascal
function CkSshTunnel_IsSshConnected(objHandle: HCkSshTunnel): wordbool; stdcall;
```

Returns `True` when the SSH transport used by this tunnel is connected; otherwise returns `False`.

This is independent of the local listener state. The listener may still be accepting local TCP connections when this method returns `False`, but those connections cannot be forwarded until a usable SSH transport exists.

For a tunnel created with `ConnectThroughSsh`, this method becomes `False` when the borrowed first-hop `Ssh` connection is disconnected.

### SshTunnel.LoadTaskCaller

`Chilkat 11.7.0 · delphidll · SshTunnel · LoadTaskCaller · method · since 9.5.0.80`

```pascal
function CkSshTunnel_LoadTaskCaller(objHandle: HCkSshTunnel;
    task: HCkTask): wordbool; stdcall;
```

Loads this object with the `SshTunnel` instance that initiated the asynchronous operation represented by `task`.

Returns True for success, False for failure.

### SshTunnel.SetAllowedAlgorithms

`Chilkat 11.7.0 · delphidll · SshTunnel · SetAllowedAlgorithms · method · since 9.5.0.99`

```pascal
function CkSshTunnel_SetAllowedAlgorithms(objHandle: HCkSshTunnel;
    json: HCkJsonObject): wordbool; stdcall;
```

Restricts the SSH connection to the algorithms specified in `json`.

This allows an application to define the exact algorithm set that may be used during SSH negotiation.

Returns True for success, False for failure.

### SshTunnel.StartKeyboardAuth

`Chilkat 11.7.0 · delphidll · SshTunnel · StartKeyboardAuth · method · since 9.5.0.78`

```pascal
function CkSshTunnel_StartKeyboardAuth(objHandle: HCkSshTunnel;
    login: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkSshTunnel__startKeyboardAuth(objHandle: HCkSshTunnel;
    login: PWideChar): PWideChar; stdcall;
```

Begins keyboard-interactive authentication for `login`.

When the server requests one or more responses, the returned XML contains the request name, instructions, and prompts:

```
<infoRequest numPrompts="N">
  <name>name text</name>
  <instruction>instruction text</instruction>
  <prompt1 echo="1_or_0">prompt text</prompt1>
  ...
  <promptN echo="1_or_0">prompt text</promptN>
</infoRequest>
```

The `echo` attribute indicates whether the response should be displayed while entered.

If authentication immediately succeeds or fails without requiring a response, the returned XML has one of these forms:

```
<success>success message</success>

<error>error message</error>
```

Pass the requested response or responses to `ContinueKeyboardAuth`.

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

Async variant: `StartKeyboardAuthAsync` — same arguments, returns a `Task` (see Async variants below).

### SshTunnel.StopAccepting

`Chilkat 11.7.0 · delphidll · SshTunnel · StopAccepting · method`

```pascal
function CkSshTunnel_StopAccepting(objHandle: HCkSshTunnel;
    waitForThread: wordbool): wordbool; stdcall;
```

Stops the local listener so that no new client connections are accepted. Existing forwarded clients remain connected and continue exchanging data.

- When `waitForThread` is `True`, the method waits for the listener thread to exit before returning.
- When it is `False`, shutdown is asynchronous and `IsAccepting` may remain `True` briefly after the method returns.

Call `BeginAccepting` again to resume accepting connections. The listener can be restarted on the same port after the previous listener has stopped.

Returns True for success, False for failure.

## Events and callbacks

### SshTunnel.AbortCheck (event)

`Chilkat 11.7.0 · delphidll · SshTunnel · AbortCheck · event`

```pascal
function MyAbortCheck(): Integer; cdecl;
```

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. Return `True` to abort; return `False` to continue (not abort)

### SshTunnel.PercentDone (event)

`Chilkat 11.7.0 · delphidll · SshTunnel · PercentDone · event`

```pascal
function MyPercentDone(pctDone: Integer): Integer; cdecl;
```

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.

Return `True` to abort; return `False` to continue (not abort)

### SshTunnel.ProgressInfo (event)

`Chilkat 11.7.0 · delphidll · SshTunnel · ProgressInfo · event`

```pascal
procedure MyProgressInfo(name: PWideChar; value: PWideChar) cdecl;
```

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.

### SshTunnel.TaskCompleted (event)

`Chilkat 11.7.0 · delphidll · SshTunnel · TaskCompleted · event`

```pascal
procedure MyTaskCompleted(task: HCkTask) cdecl;
```

Called from the background thread when an asynchronous task completes.

## Async variants

Each returns a `Task` instead of the result and takes the same arguments as the synchronous method; run the task, wait for `Finished`, then read the result from the task. No new Async methods are added from 11.7.0 on.

```pascal
function CkSshTunnel_AuthenticatePkAsync(objHandle: HCkSshTunnel;
    username: PWideChar;
    privateKey: HCkSshKey): HCkTask; stdcall;
function CkSshTunnel_AuthenticatePwAsync(objHandle: HCkSshTunnel;
    login: PWideChar;
    password: PWideChar): HCkTask; stdcall;
function CkSshTunnel_AuthenticatePwPkAsync(objHandle: HCkSshTunnel;
    username: PWideChar;
    password: PWideChar;
    privateKey: HCkSshKey): HCkTask; stdcall;
function CkSshTunnel_AuthenticateSecPwAsync(objHandle: HCkSshTunnel;
    login: HCkSecureString;
    password: HCkSecureString): HCkTask; stdcall;
function CkSshTunnel_AuthenticateSecPwPkAsync(objHandle: HCkSshTunnel;
    username: HCkSecureString;
    password: HCkSecureString;
    privateKey: HCkSshKey): HCkTask; stdcall;
function CkSshTunnel_BeginAcceptingAsync(objHandle: HCkSshTunnel;
    listenPort: Integer): HCkTask; stdcall;
function CkSshTunnel_ConnectAsync(objHandle: HCkSshTunnel;
    hostname: PWideChar;
    port: Integer): HCkTask; stdcall;
function CkSshTunnel_ConnectThroughSshAsync(objHandle: HCkSshTunnel;
    ssh: HCkSsh;
    hostname: PWideChar;
    port: Integer): HCkTask; stdcall;
function CkSshTunnel_ContinueKeyboardAuthAsync(objHandle: HCkSshTunnel;
    response: PWideChar): HCkTask; stdcall;
function CkSshTunnel_StartKeyboardAuthAsync(objHandle: HCkSshTunnel;
    login: PWideChar): HCkTask; stdcall;
```

## Related classes

[`JsonObject`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/delphidll/classes/JsonObject.md), [`SecureString`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/delphidll/classes/SecureString.md), [`Ssh`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/delphidll/classes/Ssh.md), [`SshKey`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/delphidll/classes/SshKey.md), [`Task`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/delphidll/classes/Task.md)

