try(SshClient client = SshClient.setUpDefaultClient()) { client.setServerKeyVerifier(verifier); client.start(); ConnectFuture cf = client.connect(user, sshHost, sshPort); cf.await(); try (ClientSession session = cf.getSession()) { client.stop();
@Override public SshClient build(boolean isFillWithDefaultValues) { SshClient client = super.build(isFillWithDefaultValues); client.setServerKeyVerifier(serverKeyVerifier); client.setHostConfigEntryResolver(hostConfigEntryResolver); client.setClientIdentityLoader(clientIdentityLoader); client.setFilePasswordProvider(filePasswordProvider); return client; }
/** * Setup a default client, starts it and then wraps it as a {@link SimpleClient} * * @return The {@link SimpleClient} wrapper. <B>Note:</B> when the wrapper * is closed the client is also stopped * @see #setUpDefaultClient() * @see #wrapAsSimpleClient(SshClient) */ public static SimpleClient setUpDefaultSimpleClient() { SshClient client = setUpDefaultClient(); client.start(); return wrapAsSimpleClient(client); }
public SshFtpClient() { client = SshClient.setUpDefaultClient(); client.start(); }
final AtomicReference<String> welcomeHolder = new AtomicReference<>(null); final AtomicReference<ClientSession> sessionHolder = new AtomicReference<>(null); client.setUserInteraction(new UserInteraction() { @Override public boolean isInteractionAllowed(ClientSession session) { client.start(); try (ClientSession session = client.connect(getCurrentTestName(), TEST_LOCALHOST, port).verify(7L, TimeUnit.SECONDS).getSession()) { session.addPasswordIdentity(getCurrentTestName()); session.auth().verify(5L, TimeUnit.SECONDS); assertEquals("Mismatched banner", WELCOME, welcomeHolder.get()); } finally { client.stop();
@Test public void testAuthenticationTimeout() throws Exception { final long testAuthTimeout = TimeUnit.SECONDS.toMillis(5L); PropertyResolverUtils.updateProperty(sshd, FactoryManager.AUTH_TIMEOUT, testAuthTimeout); sshd.start(); client.start(); try (ClientSession s = client.connect(getCurrentTestName(), TEST_LOCALHOST, sshd.getPort()).verify(7L, TimeUnit.SECONDS).getSession()) { Collection<ClientSession.ClientSessionEvent> res = s.waitFor(EnumSet.of(ClientSession.ClientSessionEvent.CLOSED), 2L * testAuthTimeout); assertTrue("Session should be closed: " + res, res.containsAll(EnumSet.of(ClientSession.ClientSessionEvent.CLOSED, ClientSession.ClientSessionEvent.WAIT_AUTH))); } finally { client.stop(); } }
client.setSignatureFactories(Collections.<NamedFactory<Signature>>singletonList(kexSignature)); client.setServerKeyVerifier(new ServerKeyVerifier() { @Override public boolean verifyServerKey(ClientSession sshClientSession, SocketAddress remoteAddress, PublicKey serverKey) { client.setUserAuthFactories(Collections.<NamedFactory<UserAuth>>singletonList(factory)); client.start(); try (ClientSession s = client.connect(getCurrentTestName(), TEST_LOCALHOST, port).verify(7L, TimeUnit.SECONDS).getSession()) { s.addPublicKeyIdentity(clientIdentity); s.auth().verify(11L, TimeUnit.SECONDS); } finally { client.stop();
SshClient client = SshClient.setUpDefaultClient(); if (this.session.get(SshAgent.SSH_AUTHSOCKET_ENV_NAME) != null) { client.setAgentFactory(KarafAgentFactory.getInstance()); String agentSocket = this.session.get(SshAgent.SSH_AUTHSOCKET_ENV_NAME).toString(); client.getProperties().put(SshAgent.SSH_AUTHSOCKET_ENV_NAME, agentSocket); client.setServerKeyVerifier(serverKeyVerifier); client.setKeyPairProvider(new FileKeyPairProvider()); log.debug("Created client: {}", client); client.setUserInteraction(new UserInteraction() { @Override public void welcome(ClientSession session, String banner, String lang) { client.start(); client.stop();
try { final Console console = System.console(); client = SshClient.setUpDefaultClient(); setupAgent(user, keyFile, client); client.setUserInteraction( new UserInteraction() { @Override public void welcome(ClientSession s, String banner, String lang) { client.start(); if (console != null) { console.printf("Logging in as %s\n", user); client.stop();
protected ClientSession createNativeSession() throws Exception { client = setupTestClient(); PropertyResolverUtils.updateProperty(client, FactoryManager.WINDOW_SIZE, 2048); PropertyResolverUtils.updateProperty(client, FactoryManager.MAX_PACKET_SIZE, 256); client.setTcpipForwardingFilter(AcceptAllForwardingFilter.INSTANCE); client.start(); ClientSession session = client.connect(getCurrentTestName(), TEST_LOCALHOST, sshPort).verify(7L, TimeUnit.SECONDS).getSession(); session.addPasswordIdentity(getCurrentTestName()); session.auth().verify(11L, TimeUnit.SECONDS); return session; } }
return new String(pwd); }; client.setFilePasswordProvider(passwordProvider); client.setUserInteraction(new UserInteraction() { @Override public void welcome(ClientSession s, String banner, String lang) { client.getProperties().put(ClientFactoryManager.HEARTBEAT_INTERVAL, "60000"); client.getProperties().put(ClientFactoryManager.IDLE_TIMEOUT, String.valueOf(config.getIdleTimeout())); client.getProperties().put(ClientFactoryManager.NIO2_READ_TIMEOUT, String.valueOf(config.getIdleTimeout())); client.setKeyPairProvider(new FileKeyPairProvider()); client.start(); ClientSession session = connectWithRetries(client, config); if (config.getPassword() != null) {
public static SshClient setupTestClient(Class<?> anchor) { SshClient client = SshClient.setUpDefaultClient(); client.setServerKeyVerifier(AcceptAllServerKeyVerifier.INSTANCE); client.setHostConfigEntryResolver(HostConfigEntryResolver.EMPTY); client.setKeyPairProvider(KeyPairProvider.EMPTY_KEYPAIR_PROVIDER); return client; }
@Test public void testWrongPassword() throws Exception { try (SshClient client = setupTestClient()) { client.start(); try (ClientSession s = client.connect("user", TEST_LOCALHOST, port).verify(7L, TimeUnit.SECONDS).getSession()) { s.addPasswordIdentity("bad password"); assertAuthenticationResult(getCurrentTestName(), s.auth(), false); } } }
private static ClientSession connectWithRetries(SshClient client, String username, String host, int port, int maxAttempts) throws Exception { ClientSession session = null; int retries = 0; do { ConnectFuture future = client.connect(username, host, port); future.await(); try { session = future.getSession(); } catch (Exception ex) { if (retries++ < maxAttempts) { Thread.sleep(2 * 1000); System.out.println("retrying (attempt " + retries + ") ..."); } else { throw ex; } } } while (session == null); return session; }
@Override public void closeConnection() { if (sftp != null) { client.stop(); sftp = null; } } }
@Test public void testConnectTimeout() throws Exception { SSHClient client = spy(this.client); SshClient ssh = spy(SshClient.setUpDefaultClient()); ConnectFuture future = mock(ConnectFuture.class); doReturn(ssh).when(client).createSshClient(); doReturn(future).when(ssh).connect(any(), any(), anyInt()); when(future.await(anyLong())).thenReturn(false); assertThrows(TimeLimitExceededException.class, client::connect); }
client.setFilePasswordProvider(ui); client.setUserInteraction(ui); client.start();
client = createSshClient(); client.setServerKeyVerifier( (sshClientSession, remoteAddress, serverKey) -> { hostKey = serverKey; }); client.start(); ConnectFuture cfuture = client.connect(user, host, port); if (!cfuture.await(softTimeout)) { throw new TimeLimitExceededException(
super.checkConfig(); Objects.requireNonNull(getForwarderFactory(), "ForwarderFactory not set"); Objects.requireNonNull(getServerKeyVerifier(), "ServerKeyVerifier not set"); Objects.requireNonNull(getHostConfigEntryResolver(), "HostConfigEntryResolver not set"); Objects.requireNonNull(getClientIdentityLoader(), "ClientIdentityLoader not set"); Objects.requireNonNull(getFilePasswordProvider(), "FilePasswordProvider not set"); KeyPairProvider defaultIdentities = getKeyPairProvider(); if (defaultIdentities == null) { setKeyPairProvider(new DefaultClientIdentitiesWatcher(this::getClientIdentityLoader, this::getFilePasswordProvider)); SshAgentFactory agentFactory = getAgentFactory(); if (agentFactory != null) { List<NamedFactory<Channel>> forwarders = ValidateUtils.checkNotNullAndNotEmpty( agentFactory.getChannelForwardingFactories(this), "No agent channel forwarding factories for %s", agentFactory); List<NamedFactory<Channel>> factories = getChannelFactories(); if (GenericUtils.isEmpty(factories)) { factories = forwarders; setChannelFactories(factories); if (GenericUtils.isEmpty(getServiceFactories())) { setServiceFactories(DEFAULT_SERVICE_FACTORIES); if (GenericUtils.isEmpty(getUserAuthFactories())) { setUserAuthFactories(DEFAULT_USER_AUTH_FACTORIES);
super.checkConfig(); Objects.requireNonNull(getForwarderFactory(), "ForwarderFactory not set"); Objects.requireNonNull(getServerKeyVerifier(), "ServerKeyVerifier not set"); Objects.requireNonNull(getHostConfigEntryResolver(), "HostConfigEntryResolver not set"); Objects.requireNonNull(getClientIdentityLoader(), "ClientIdentityLoader not set"); Objects.requireNonNull(getFilePasswordProvider(), "FilePasswordProvider not set"); KeyIdentityProvider defaultIdentities = getKeyIdentityProvider(); if (defaultIdentities == null) { setKeyIdentityProvider(new DefaultClientIdentitiesWatcher(this::getClientIdentityLoader, this::getFilePasswordProvider)); SshAgentFactory agentFactory = getAgentFactory(); if (agentFactory != null) { List<NamedFactory<Channel>> forwarders = ValidateUtils.checkNotNullAndNotEmpty( agentFactory.getChannelForwardingFactories(this), "No agent channel forwarding factories for %s", agentFactory); List<NamedFactory<Channel>> factories = getChannelFactories(); if (GenericUtils.isEmpty(factories)) { factories = forwarders; setChannelFactories(factories); if (GenericUtils.isEmpty(getServiceFactories())) { setServiceFactories(DEFAULT_SERVICE_FACTORIES); if (GenericUtils.isEmpty(getUserAuthFactories())) { setUserAuthFactories(DEFAULT_USER_AUTH_FACTORIES);