SshConnector (Maverick Legacy - Client Assembly 1.7.61 API)

java.lang.Object
- com.maverick.ssh.SshConnector

All Implemented Interfaces:

SshClientConnector
```
public final class SshConnector
extends Object
implements SshClientConnector
```
Connecting to an SSH server STARTS HERE!. This utility class establishes a connection with an SSH server, determines which SSH protocol versions are supported and creates an initialized connection ready for authentication. Both SSH1 and SSH2 protocol support is included, however it is possible to restrict either version by removing the maverick-ssh1.jar or maverick-ssh2.jar from your classpath or by using the setSupportedVersions(int versions) method.

Each call to createInstance() returns a new instance of the connector with a pair of configuration contexts, one for SSH1 and another for SSH2. These contexts are represented by the interface SshContext and have a default set of configuration methods; further protocol specific configuration methods can be obtained by casting the values returned by getContext(int version) into either the Ssh1Context or Ssh2Context implementations.

To connect to an SSH server you need to provide an SshTransport which provides the transport layer communication. In most cases this will be a Socket however since this API is designed for many different platforms, a Socket may not always be available so this simple interface is used to allow you to specify the source IO streams. The SshTransport documentation provides a simple example for a Socket called SocketTransport which is used in the following examples.

To create a connection and authentication using password authentication with default configuration contexts use:
```
 SshConnector con = SshConnector.getInstance();
 SshClient ssh = con.connect(new SocketTransport("beagle2.sshtools.net", 22),
                "martianx");
 
 PasswordAuthentication pwd = new PasswordAuthentication();
 pwd.setPassword("likeidgivethataway!");
 
 if (ssh.authenticate(pwd) == SshAuthentication.COMPLETE) {
        System.out.println("Authentication succeeded");
        SshSession sesison = ssh.openSessionChannel();
 } else {
        System.out.println("Authentication failed");
 }
 
```
To configure host key verification for a connector use the following code:
```
 SshConnector con = SshConnector.getInstance();
 
 HostKeyVerification hkv = new HostKeyVerification() {
   public boolean verifyHost(String name, SshPublicKey key)
              throws IOException {
      // Verify the host somehow???
      return true;
   }
 };
 SshContext context = con.getContext(SshConnector.SSH1);
 context.setHostKeyVerification(hkv);
 
 context = con.getContext(SshConnector.SSH2);
 context.setHostKeyVerification(hkv);
 
 SshClient ssh = con.connect(
                new SocketTransport("beagle2.sshtools.net", 22),
                "martianx");
 
  .......
 
```
You can then create as many connections are required using the same configuration contexts.

To configure protocol specific features, for example the showing of authentication banners from SSH2 servers use:
```
 SshConnector con = SshConnector.getInstance();
 
 Ssh2Context context = (Ssh2Context) con.getContext(SshConnector.SSH2);
 context.setBannerDisplay(new BannerDisplay() {
   public void displayBanner(String message) {
     // Popup a dialog with the message??
   }
 });
 
 SshClient ssh = con.connect(
                new SocketTransport("beagle2.sshtools.net", 22),
                "martianx");
 
 ......
 
```
Author:

Lee David Painter

Field Summary

Fields
Modifier and Type	Field and Description
`static Throwable`	`initException`
`static int`	`SSH1` Constant for the SSH protocol version 1
`static int`	`SSH2` Constant for the SSH protocol version 2

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static void`	`addEventListener(EventListener listener)`
`static void`	`addEventListener(String threadPrefix, EventListener listener)`
`void`	`addListener(SshClientListener listener)`
`SshClient`	`connect(SshTransport transport, String username)` Create a new connection to an SSH server over the specified transport.
`SshClient`	`connect(SshTransport transport, String username, boolean buffered)` See `SshClientConnector.connect(SshTransport, String)` for full details.
`SshClient`	`connect(SshTransport transport, String username, boolean buffered, SshContext context)` See `SshClientConnector.connect(SshTransport, String)` for full details.
`SshClient`	`connect(SshTransport transport, String username, SshContext context)` See `SshClientConnector.connect(SshTransport, String)` for full details.
`static SshConnector`	`createInstance()` Deprecated. Use alternative createInstance method that specifies a minimum SecurityLevel for your application and
`static SshConnector`	`createInstance(ExecutorService executorService)` Deprecated. Use alternative createInstance method that specifies a minimum SecurityLevel for your application
`static SshConnector`	`createInstance(ExecutorService executor, SecurityLevel securityLevel, boolean managedSecurity)` Returns an instance of the `SshConnector`.
`static SshConnector`	`createInstance(ExecutorService executor, SecurityPolicy securityPolicy)`
`static SshConnector`	`createInstance(SecurityLevel securityLevel, boolean managedSecurity)`
`static SshConnector`	`createInstance(SecurityPolicy securityPolicy)`
`static SshConnector`	`createManagedInstance(SecurityLevel securityLevel)`
`int`	`determineVersion(SshTransport transport)` Determine the version of the server connected to the SshTransport.
`void`	`enableFIPSMode()` Deprecated. This method is out-of-date. Use JCEProvider.initializeDefaultProvider("BCFIPS") passing a FIPS approved JCE provider in approved mode to restrict algorithms to only those supported by the approved FIPS environment.
`static String`	`getAvailableCiphers()`
`static String`	`getAvailableCiphers(SecurityLevel securityLevel)`
`static String`	`getAvailableCompressions()`
`static String`	`getAvailableKeyExchanges()`
`static String`	`getAvailableKeyExchanges(SecurityLevel securityLevel)`
`static String`	`getAvailableMacs()`
`static String`	`getAvailableMacs(SecurityLevel securityLevel)`
`static String`	`getAvailablePublicKeys()`
`static String`	`getAvailablePublicKeys(SecurityLevel securityLevel)`
`Ssh2Context`	`getContext()` Get the SSH2 context
`SshContext`	`getContext(int version)` Deprecated. Future version will only support SSH2. Use getContext without parameters.
`static String`	`getDefaultConfiguration(SecurityLevel securityLevel)`
`int`	`getInitialTimeout()` Get the initial socket timeout for SSH identification.
`int`	`getMaximumRetryAttempts()`
`String`	`getProduct()`
`static Date`	`getReleaseDate()` Returns the release date of the current version.
`int`	`getRetryIntervalSeconds()`
`int`	`getSupportedVersions()` Deprecated. Future version will only support SSH2
`static String`	`getVersion()` Returns the current version of the API.
`boolean`	`isLicensed()` Indicates whether the API is licensed or not
`static void`	`printDefaultConfiguration()`
`static void`	`removeEventListener(String threadPrefix)`
`void`	`removeListener(SshClientListener listener)`
`static void`	`setCoreThreadPoolSize(int coreThreadPoolSize)` Deprecated.
`void`	`setInitialTimeout(int initialTimeout)` Set the initial timeout for SSH identification.
`void`	`setKnownHosts(HostKeyVerification hkv)` Set the `HostKeyVerification` instance for both protocols.
`static void`	`setMaximumNumberThreads(int maximumNumberThreads)` Deprecated.
`void`	`setMaximumRetryAttempts(int maximumRetryAttempts)`
`void`	`setProduct(String product)`
`void`	`setRetryIntervalSeconds(int retryIntervalSeconds)`
`void`	`setSoftwareVersionComments(String softwareComments)` Set the software/version/comments field of the SSH identification string
`void`	`setSupportedVersions(int supported)` Deprecated. Future version will only support SSH2
`static void`	`setThreadTimeout(long threadTimeout)` Deprecated.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - SSH1
```
public static final int SSH1
```
    Constant for the SSH protocol version 1
    
    See Also:
    
    Constant Field Values
  - SSH2
```
public static final int SSH2
```
    Constant for the SSH protocol version 2
    
    See Also:
    
    Constant Field Values
  - initException
```
public static Throwable initException
```
- Method Detail
  - addListener
```
public void addListener(SshClientListener listener)
```
  - removeListener
```
public void removeListener(SshClientListener listener)
```
  - setCoreThreadPoolSize
```
@Deprecated
public static void setCoreThreadPoolSize(int coreThreadPoolSize)
```
    Deprecated.
  - setMaximumNumberThreads
```
@Deprecated
public static void setMaximumNumberThreads(int maximumNumberThreads)
```
    Deprecated.
  - setThreadTimeout
```
@Deprecated
public static void setThreadTimeout(long threadTimeout)
```
    Deprecated.
  - createInstance
```
@Deprecated
public static SshConnector createInstance()
                                               throws SshException
```
    Deprecated. Use alternative createInstance method that specifies a minimum SecurityLevel for your application and
    
    Returns:
    
    Throws:
    
    SshException
  - createInstance
```
@Deprecated
public static SshConnector createInstance(ExecutorService executorService)
                                               throws SshException
```
    Deprecated. Use alternative createInstance method that specifies a minimum SecurityLevel for your application
    
    Returns:
    
    Throws:
    
    SshException
  - createManagedInstance
```
public static SshConnector createManagedInstance(SecurityLevel securityLevel)
                                          throws SshException
```
    Throws:
    
    SshException
  - createInstance
```
public static SshConnector createInstance(SecurityLevel securityLevel,
                                          boolean managedSecurity)
                                   throws SshException
```
    Throws:
    
    SshException
  - createInstance
```
public static SshConnector createInstance(ExecutorService executor,
                                          SecurityLevel securityLevel,
                                          boolean managedSecurity)
                                   throws SshException
```
    Returns an instance of the SshConnector. Each instance is initialized with a pair of default contexts.
    
    Returns:
    
    a new instance
    
    Throws:
    
    SshException
  - createInstance
```
public static SshConnector createInstance(SecurityPolicy securityPolicy)
                                   throws SshException
```
    Throws:
    
    SshException
  - createInstance
```
public static SshConnector createInstance(ExecutorService executor,
                                          SecurityPolicy securityPolicy)
                                   throws SshException
```
    Throws:
    
    SshException
  - addEventListener
```
public static void addEventListener(EventListener listener)
```
  - addEventListener
```
public static void addEventListener(String threadPrefix,
                                    EventListener listener)
```
  - removeEventListener
```
public static void removeEventListener(String threadPrefix)
```
  - enableFIPSMode
```
@Deprecated
public final void enableFIPSMode()
                                      throws SshException
```
    Deprecated. This method is out-of-date. Use JCEProvider.initializeDefaultProvider("BCFIPS") passing a FIPS approved JCE provider in approved mode to restrict algorithms to only those supported by the approved FIPS environment.
    
    Throws:
    
    SshException
  - isLicensed
```
public final boolean isLicensed()
```
    Indicates whether the API is licensed or not
    
    Returns:
    
    boolean
  - getContext
```
@Deprecated
public SshContext getContext(int version)
                                  throws SshException
```
    Deprecated. Future version will only support SSH2. Use getContext without parameters.
    Get the configuration context for a specific SSH version.
    SshConnector con = SshConnector.getInstance(); SshContext context = con.getContext(SshConnector.SSH1);
    or
    SshContext context = con.getContext(SshConnector.SSH2);
    You can cast the returned value into the context implementation to get access to protocol specific configuration.
    Ssh2Context context = (Ssh2Context) con.getContext(SshConnector.SSH2);
    Parameters:
    
    version - either SshConnector.SSH1 or SshConnector.SSH2
    
    Returns:
    
    the version context
    
    Throws:
    
    SshException
  - getContext
```
public Ssh2Context getContext()
                       throws SshException
```
    Get the SSH2 context
    
    Returns:
    
    Throws:
    
    SshException
  - setSupportedVersions
```
@Deprecated
public void setSupportedVersions(int supported)
                                      throws SshException
```
    Deprecated. Future version will only support SSH2
    Sets the protocol versions supported by this connector. When the connector is created, the supported flags are set to whichever protocol support is installed. You can restrict support by setting the support to an individual version using this method. For example you could restrict access to SSH2 by using the following code:
    SshConnector con = SshConnector.getInstance(); con.setSupportedVersions(SshConnector.SSH2);
    or switch back to full support:
    con.setSupportedVersions(SshConnector.SSH1 | SshConnector.SSH2);
    Parameters:
    
    supported -
    
    Throws:
    
    SshException
  - getSupportedVersions
```
@Deprecated
public int getSupportedVersions()
```
    Deprecated. Future version will only support SSH2
    
    Returns the supported protocol flags.
    
    Returns:
    
    a bit mask of the supported protocol versions for example SshConnector.SSH1 & SshConnector.SSH2
  - setKnownHosts
```
public void setKnownHosts(HostKeyVerification hkv)
```
    Set the HostKeyVerification instance for both protocols. You can use this method to configure both protocols at once instead of using seperate calls on each of the SshContext's.
    
    Parameters:
    
    hkv -
  - connect
```
public SshClient connect(SshTransport transport,
                         String username)
                  throws SshException
```
    Description copied from interface: SshClientConnector
    
    Create a new connection to an SSH server over the specified transport. This method reads the remote servers identification and determines which protocol support is required. An SshClient instance is then created, initialized and returned. If both protocol versions are supported by the remote server the connector will always operate using SSH2.
    
    The SshTransport interface is used here to allow different types of transport mechanisms. Typically this would be a Socket however since this API is targeted at all Java platforms a Socket cannot be used directly. See the SshTransport documentation for an example Socket implementation.
    
    To take advantage of protocol specific features you can test the instance returned which will either be an Ssh1Client or Ssh2Client.
    
    Specified by:
    
    connect in interface SshClientConnector
    
    Parameters:
    
    transport - the transport for the connection.
    
    username - the name of the user connecting
    
    Returns:
    
    a connected SshClient instance ready for authentication.
    
    Throws:
    
    SshException
    
    See Also:
    
    Ssh1Client, Ssh2Client
  - connect
```
public SshClient connect(SshTransport transport,
                         String username,
                         boolean buffered)
                  throws SshException
```
    Description copied from interface: SshClientConnector
    
    See SshClientConnector.connect(SshTransport, String) for full details. This method optionally allows you to specify the buffered state of the connection. When the connection is buffered a background thread is started to act as a message pump; this has the benefit of routing data as soon as it arrives and helps in circumstances where you require a channel to fill up with data without calling its InputStream's read method. This also will enable the InputStreams available method to work as expected.
    
    Specified by:
    
    connect in interface SshClientConnector
    
    Parameters:
    
    transport - SshTransport
    
    username - String
    
    buffered - boolean
    
    Returns:
    
    SshClient
    
    Throws:
    
    SshException
  - connect
```
public SshClient connect(SshTransport transport,
                         String username,
                         SshContext context)
                  throws SshException
```
    Description copied from interface: SshClientConnector
    
    See SshClientConnector.connect(SshTransport, String) for full details. This method optionally allows you to specify a context to use. Normally you would reused an SshConnector instead of calling this method directly.
    
    Specified by:
    
    connect in interface SshClientConnector
    
    Parameters:
    
    transport - SshTransport
    
    username - String
    
    context - SshContext
    
    Returns:
    
    SshClient
    
    Throws:
    
    SshException
  - setSoftwareVersionComments
```
public void setSoftwareVersionComments(String softwareComments)
```
    Set the software/version/comments field of the SSH identification string
    
    Parameters:
    
    softwareComments - String
  - connect
```
public SshClient connect(SshTransport transport,
                         String username,
                         boolean buffered,
                         SshContext context)
                  throws SshException
```
    Description copied from interface: SshClientConnector
    
    See SshClientConnector.connect(SshTransport, String) for full details.
    This method optionally allows you to specify the buffered state of the connection. When the connection is buffered a background thread is started to act as a message pump; this has the benefit of routing data as soon as it arrives and helps in circumstances where you require a channel to fill up with data without calling its InputStream's read method. This also will enable the InputStreams available method to work as expected.
    
    This method also allows you to specify a context to use. Normally you would reuse an SshConnector instead of calling this method directly.
    
    Specified by:
    
    connect in interface SshClientConnector
    
    Parameters:
    
    transport - SshTransport
    
    username - String
    
    buffered - boolean
    
    context - SshContext
    
    Returns:
    
    SshClient
    
    Throws:
    
    SshException
  - getVersion
```
public static String getVersion()
```
    Returns the current version of the API.
    
    Returns:
    
    the current version in the form MAJOR.MINOR.BUILD
  - getReleaseDate
```
public static Date getReleaseDate()
```
    Returns the release date of the current version.
    
    Returns:
    
    the release date of the current version.
  - determineVersion
```
public int determineVersion(SshTransport transport)
                     throws SshException
```
    Determine the version of the server connected to the SshTransport. This method will close the transport before completing. Only use for informational purposes.
    
    Parameters:
    
    transport -
    
    Returns:
    
    a bit mask of the supported versions.
    
    Throws:
    
    SshException
  - getInitialTimeout
```
public int getInitialTimeout()
```
    Get the initial socket timeout for SSH identification.
    
    Returns:
  - setInitialTimeout
```
public void setInitialTimeout(int initialTimeout)
```
    Set the initial timeout for SSH identification.
    
    Parameters:
    
    initialTimeout - the number of milliseconds to use as the socket timeout.
  - getProduct
```
public String getProduct()
```
  - setProduct
```
public void setProduct(String product)
```
  - getMaximumRetryAttempts
```
public int getMaximumRetryAttempts()
```
  - setMaximumRetryAttempts
```
public void setMaximumRetryAttempts(int maximumRetryAttempts)
```
  - getRetryIntervalSeconds
```
public int getRetryIntervalSeconds()
```
  - setRetryIntervalSeconds
```
public void setRetryIntervalSeconds(int retryIntervalSeconds)
```
  - getAvailableCiphers
```
public static String getAvailableCiphers(SecurityLevel securityLevel)
                                  throws SshException
```
    Throws:
    
    SshException
  - getAvailableMacs
```
public static String getAvailableMacs(SecurityLevel securityLevel)
                               throws SshException
```
    Throws:
    
    SshException
  - getAvailablePublicKeys
```
public static String getAvailablePublicKeys(SecurityLevel securityLevel)
                                     throws SshException
```
    Throws:
    
    SshException
  - getAvailableKeyExchanges
```
public static String getAvailableKeyExchanges(SecurityLevel securityLevel)
                                       throws SshException
```
    Throws:
    
    SshException
  - printDefaultConfiguration
```
public static void printDefaultConfiguration()
                                      throws SshException
```
    Throws:
    
    SshException
  - getAvailableCompressions
```
public static String getAvailableCompressions()
                                       throws SshException
```
    Throws:
    
    SshException
  - getAvailableMacs
```
public static String getAvailableMacs()
                               throws SshException
```
    Throws:
    
    SshException
  - getAvailableCiphers
```
public static String getAvailableCiphers()
                                  throws SshException
```
    Throws:
    
    SshException
  - getAvailableKeyExchanges
```
public static String getAvailableKeyExchanges()
                                       throws SshException
```
    Throws:
    
    SshException
  - getAvailablePublicKeys
```
public static String getAvailablePublicKeys()
                                     throws SshException
```
    Throws:
    
    SshException
  - getDefaultConfiguration
```
public static String getDefaultConfiguration(SecurityLevel securityLevel)
                                      throws SshException
```
    Throws:
    
    SshException

Class SshConnector

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

SSH1

SSH2

initException

Method Detail

addListener

removeListener

setCoreThreadPoolSize

setMaximumNumberThreads

setThreadTimeout

createInstance

createInstance

createManagedInstance

createInstance

createInstance

createInstance

createInstance

addEventListener

addEventListener

removeEventListener

enableFIPSMode

isLicensed

getContext

getContext

setSupportedVersions

getSupportedVersions

setKnownHosts

connect

connect

connect

setSoftwareVersionComments

connect

getVersion

getReleaseDate

determineVersion

getInitialTimeout

setInitialTimeout

getProduct

setProduct

getMaximumRetryAttempts

setMaximumRetryAttempts

getRetryIntervalSeconds

setRetryIntervalSeconds

getAvailableCiphers

getAvailableMacs

getAvailablePublicKeys

getAvailableKeyExchanges

printDefaultConfiguration

getAvailableCompressions

getAvailableMacs

getAvailableCiphers

getAvailableKeyExchanges

getAvailablePublicKeys

getDefaultConfiguration