org.eclipse.jgit.transport.sshd

Class SshdSessionFactory

java.lang.Object

org.eclipse.jgit.transport.SshSessionFactory

org.eclipse.jgit.transport.sshd.SshdSessionFactory

All Implemented Interfaces:

java.io.Closeable, java.lang.AutoCloseable

public class SshdSessionFactory
extends SshSessionFactory
implements java.io.Closeable

A SshSessionFactory that uses Apache MINA sshd. Classes from Apache MINA sshd are kept private to avoid API evolution problems when Apache MINA sshd interfaces change.

Since:

5.2

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
private static class	SshdSessionFactory.Tuple A simple general map key.

Field Summary

Fields

Modifier and Type	Field and Description
private java.util.concurrent.atomic.AtomicBoolean	closing
private java.util.Map<SshdSessionFactory.Tuple,org.apache.sshd.client.config.hosts.HostConfigEntryResolver>	defaultHostConfigEntryResolver
private java.util.Map<SshdSessionFactory.Tuple,java.lang.Iterable<java.security.KeyPair>>	defaultKeys
private java.util.Map<SshdSessionFactory.Tuple,org.apache.sshd.client.keyverifier.ServerKeyVerifier>	defaultServerKeyVerifier
private java.io.File	homeDirectory
private KeyCache	keyCache
private ProxyDataFactory	proxies
private java.util.Set<SshdSession>	sessions
private java.io.File	sshDirectory

Constructor Summary

Constructors

Constructor and Description
SshdSessionFactory() Creates a new SshdSessionFactory without key cache and a DefaultProxyDataFactory.
SshdSessionFactory(KeyCache keyCache, ProxyDataFactory proxies) Creates a new SshdSessionFactory using the given KeyCache and ProxyDataFactory.

Method Summary

Modifier and Type	Method and Description
void	close()
private org.apache.sshd.common.config.keys.FilePasswordProvider	createFilePasswordProvider(KeyPasswordProvider provider) Creates a FilePasswordProvider for a new session.
protected KeyPasswordProvider	createKeyPasswordProvider(CredentialsProvider provider) Creates a KeyPasswordProvider for a new session.
protected java.util.List<java.nio.file.Path>	getDefaultIdentities(java.io.File sshDir) Gets a list of default identities, i.e., private key files that shall always be tried for public key authentication.
protected java.lang.Iterable<java.security.KeyPair>	getDefaultKeys(java.io.File sshDir) Determines the default keys.
protected java.util.List<java.nio.file.Path>	getDefaultKnownHostsFiles(java.io.File sshDir) Gets the list of default user known hosts files.
protected java.lang.String	getDefaultPreferredAuthentications() Gets the list of default preferred authentication mechanisms.
java.io.File	getHomeDirectory() Retrieves the global user home directory
private org.apache.sshd.client.config.hosts.HostConfigEntryResolver	getHostConfigEntryResolver(java.io.File homeDir, java.io.File sshDir) Obtain a HostConfigEntryResolver to read the ssh config file and to determine host entries for connections.
protected KeyCache	getKeyCache() Obtains the KeyCache to use to cache loaded keys.
private org.apache.sshd.client.keyverifier.ServerKeyVerifier	getServerKeyVerifier(java.io.File homeDir, java.io.File sshDir) Obtain a ServerKeyVerifier to read known_hosts files and to verify server host keys.
SshdSession	getSession(URIish uri, CredentialsProvider credentialsProvider, FS fs, int tms) Open (or reuse) a session to a host.
java.io.File	getSshDirectory() Retrieves the global .ssh directory
private java.util.List<org.apache.sshd.common.NamedFactory<org.apache.sshd.client.auth.UserAuth>>	getUserAuthFactories() Gets the user authentication mechanisms (or rather, factories for them).
private void	register(SshdSession newSession)
void	setHomeDirectory(java.io.File homeDir) Set a global directory to use as the user's home directory
void	setSshDirectory(java.io.File sshDir) Set a global directory to use as the .ssh directory
private org.apache.sshd.common.keyprovider.KeyIdentityProvider	toKeyIdentityProvider(java.lang.Iterable<java.security.KeyPair> keys) Converts an Iterable of {link KeyPair}s into a KeyIdentityProvider.
private void	unregister(SshdSession oldSession)

Methods inherited from class org.eclipse.jgit.transport.SshSessionFactory

getInstance, getLocalUserName, releaseSession, setInstance

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

closing

private final java.util.concurrent.atomic.AtomicBoolean closing

sessions

private final java.util.Set<SshdSession> sessions

defaultHostConfigEntryResolver

private final java.util.Map<SshdSessionFactory.Tuple,org.apache.sshd.client.config.hosts.HostConfigEntryResolver> defaultHostConfigEntryResolver

defaultServerKeyVerifier

private final java.util.Map<SshdSessionFactory.Tuple,org.apache.sshd.client.keyverifier.ServerKeyVerifier> defaultServerKeyVerifier

defaultKeys

private final java.util.Map<SshdSessionFactory.Tuple,java.lang.Iterable<java.security.KeyPair>> defaultKeys

keyCache

private final KeyCache keyCache

proxies

private final ProxyDataFactory proxies

sshDirectory

private java.io.File sshDirectory

homeDirectory

private java.io.File homeDirectory

Constructor Detail

SshdSessionFactory

public SshdSessionFactory()

Creates a new SshdSessionFactory without key cache and a DefaultProxyDataFactory.

SshdSessionFactory

public SshdSessionFactory(KeyCache keyCache,
                          ProxyDataFactory proxies)

Creates a new SshdSessionFactory using the given KeyCache and ProxyDataFactory. The keyCache is used for all sessions created through this session factory; cached keys are destroyed when the session factory is closed.

Caching ssh keys in memory for an extended period of time is generally considered bad practice, but there may be circumstances where using a KeyCache is still the right choice, for instance to avoid that a user gets prompted several times for the same password for the same key. In general, however, it is preferable not to use a key cache but to use a KeyPasswordProvider that has access to some secure storage and can save and retrieve passwords from there without user interaction. Another approach is to use an ssh agent.

Note that the underlying ssh library (Apache MINA sshd) may or may not keep ssh keys in memory for unspecified periods of time irrespective of the use of a KeyCache.

Parameters:

keyCache - KeyCache to use for caching ssh keys, or null to not use a key cache

proxies - ProxyDataFactory to use, or null to not use a proxy database (in which case connections through proxies will not be possible)

Method Detail

getSession

public SshdSession getSession(URIish uri,
                              CredentialsProvider credentialsProvider,
                              FS fs,
                              int tms)
                       throws TransportException

Description copied from class: SshSessionFactory

Open (or reuse) a session to a host.

A reasonable UserInfo that can interact with the end-user (if necessary) is installed on the returned session by this method.

The caller must connect the session by invoking connect() if it has not already been connected.

Specified by:

getSession in class SshSessionFactory

Parameters:

uri - URI information about the remote host

credentialsProvider - provider to support authentication, may be null.

fs - the file system abstraction which will be necessary to perform certain file system operations.

tms - Timeout value, in milliseconds.

Returns:

a session that can contact the remote host.

Throws:

TransportException - the session could not be created.

close

public void close()

Specified by:

close in interface java.io.Closeable

Specified by:

close in interface java.lang.AutoCloseable

register

private void register(SshdSession newSession)
               throws java.io.IOException

Throws:

java.io.IOException

unregister

private void unregister(SshdSession oldSession)

setHomeDirectory

public void setHomeDirectory(@NonNull
                             java.io.File homeDir)

Set a global directory to use as the user's home directory

Parameters:

homeDir - to use

getHomeDirectory

public java.io.File getHomeDirectory()

Retrieves the global user home directory

Returns:

the directory, or null if not set

setSshDirectory

public void setSshDirectory(@NonNull
                            java.io.File sshDir)

Set a global directory to use as the .ssh directory

Parameters:

sshDir - to use

getSshDirectory

public java.io.File getSshDirectory()

Retrieves the global .ssh directory

Returns:

the directory, or null if not set

getHostConfigEntryResolver

@NonNull
private org.apache.sshd.client.config.hosts.HostConfigEntryResolver getHostConfigEntryResolver(@NonNull
                                                                                                        java.io.File homeDir,
                                                                                                        @NonNull
                                                                                                        java.io.File sshDir)

Obtain a HostConfigEntryResolver to read the ssh config file and to determine host entries for connections.

Parameters:

homeDir - home directory to use for ~ replacement

sshDir - to use for looking for the config file

Returns:

the resolver

getServerKeyVerifier

@NonNull
private org.apache.sshd.client.keyverifier.ServerKeyVerifier getServerKeyVerifier(@NonNull
                                                                                           java.io.File homeDir,
                                                                                           @NonNull
                                                                                           java.io.File sshDir)

Obtain a ServerKeyVerifier to read known_hosts files and to verify server host keys. The default implementation returns a ServerKeyVerifier that recognizes the two openssh standard files ~/.ssh/known_hosts and ~/.ssh/known_hosts2 as well as any files configured via the UserKnownHostsFile option in the ssh config file.

Parameters:

homeDir - home directory to use for ~ replacement

sshDir - representing ~/.ssh/

Returns:

the resolver

getDefaultKnownHostsFiles

@NonNull
protected java.util.List<java.nio.file.Path> getDefaultKnownHostsFiles(@NonNull
                                                                                java.io.File sshDir)

Gets the list of default user known hosts files. The default returns ~/.ssh/known_hosts and ~/.ssh/known_hosts2. The ssh config UserKnownHostsFile overrides this default.

Parameters:

sshDir -

Returns:

the possibly empty list of default known host file paths.

getDefaultKeys

@NonNull
protected java.lang.Iterable<java.security.KeyPair> getDefaultKeys(@NonNull
                                                                            java.io.File sshDir)

Determines the default keys. The default implementation will lazy load the default identity files.

Subclasses may override and return an Iterable of whatever keys are appropriate. If the returned iterable lazily loads keys, it should be an instance of AbstractResourceKeyPairProvider so that the session can later pass it the password provider wrapped as a FilePasswordProvider via AbstractResourceKeyPairProvider#setPasswordFinder(FilePasswordProvider) so that encrypted, password-protected keys can be loaded.

The default implementation uses exactly this mechanism; class CachingKeyPairProvider may serve as a model for a customized lazy-loading Iterable implementation

If the Iterable returned has the keys already pre-loaded or otherwise doesn't need to decrypt encrypted keys, it can be any Iterable, for instance a simple List.

Parameters:

sshDir - to look in for keys

Returns:

an Iterable over the default keys

Since:

5.3

toKeyIdentityProvider

private org.apache.sshd.common.keyprovider.KeyIdentityProvider toKeyIdentityProvider(java.lang.Iterable<java.security.KeyPair> keys)

Converts an Iterable of {link KeyPair}s into a KeyIdentityProvider.

Parameters:

keys - to provide via the returned KeyIdentityProvider

Returns:

a KeyIdentityProvider that provides the given keys

getDefaultIdentities

@NonNull
protected java.util.List<java.nio.file.Path> getDefaultIdentities(@NonNull
                                                                           java.io.File sshDir)

Gets a list of default identities, i.e., private key files that shall always be tried for public key authentication. Typically those are ~/.ssh/id_dsa, ~/.ssh/id_rsa, and so on. The default implementation returns the files defined in SshConstants.DEFAULT_IDENTITIES.

Parameters:

sshDir - the directory that represents ~/.ssh/

Returns:

a possibly empty list of paths containing default identities (private keys)

getKeyCache

protected final KeyCache getKeyCache()

Obtains the KeyCache to use to cache loaded keys.

Returns:

the KeyCache, or null if none.

createKeyPasswordProvider

@NonNull
protected KeyPasswordProvider createKeyPasswordProvider(CredentialsProvider provider)

Creates a KeyPasswordProvider for a new session.

Parameters:

provider - the CredentialsProvider to delegate to for user interactions

Returns:

a new KeyPasswordProvider

createFilePasswordProvider

@NonNull
private org.apache.sshd.common.config.keys.FilePasswordProvider createFilePasswordProvider(KeyPasswordProvider provider)

Creates a FilePasswordProvider for a new session.

Parameters:

provider - the KeyPasswordProvider to delegate to

Returns:

a new FilePasswordProvider

getUserAuthFactories

@NonNull
private java.util.List<org.apache.sshd.common.NamedFactory<org.apache.sshd.client.auth.UserAuth>> getUserAuthFactories()

Gets the user authentication mechanisms (or rather, factories for them). By default this returns gssapi-with-mic, public-key, password, and keyboard-interactive, in that order. The order is only significant if the ssh config does not set PreferredAuthentications; if it is set, the order defined there will be taken.

Returns:

the non-empty list of factories.

getDefaultPreferredAuthentications

protected java.lang.String getDefaultPreferredAuthentications()

Gets the list of default preferred authentication mechanisms. If null is returned the openssh default list will be in effect. If the ssh config defines PreferredAuthentications the value from the ssh config takes precedence.

Returns:

a comma-separated list of algorithm names, or null if none