private boolean setupJSchIdentityRepository (JSch jsch, String identityFile, boolean preferAgent) throws JSchException { boolean agentUsed = false; if (preferAgent) { Connector con = ConnectorFactory.getInstance().createConnector(ConnectorFactory.ConnectorKind.ANY); if (con != null) { IdentityRepository irepo = new IdentityRepositoryImpl(con); if (irepo.getStatus() == IdentityRepository.RUNNING) { jsch.setIdentityRepository(irepo); agentUsed = true; } } } if (!agentUsed) { jsch.setIdentityRepository(null); // remove all identity files jsch.removeAllIdentity(); // and add the one specified by CredentialsProvider jsch.addIdentity(identityFile); } return agentUsed; }
public JschSshClient(HostAndPort socket, LoginCredentials loginCredentials, int timeout, Optional<Connector> agentConnector, BackoffLimitedRetryHandler backoffLimitedRetryHandler) { this.host = checkNotNull(socket, "host").getHost(); this.user = checkNotNull(loginCredentials, "credentials for %s", host).getUser(); checkArgument(socket.getPort() > 0, "ssh port must be greater than zero" + socket.getPort()); checkArgument(socket.getPort() < 65535, "ssh port must be less than 65535" + socket.getPort()); this.backoffLimitedRetryHandler = checkNotNull(backoffLimitedRetryHandler, "backoffLimitedRetryHandler"); connection = SshConnection.builder() .hostAndPort(socket) .loginCredentials(loginCredentials) .connectionTimeout(timeout) .agentConnector(agentConnector) .build(); checkNotNull(connection); }
private Session newSession() throws JSchException { JSch jSch = new JSch(); try { jSch.setConfig("PreferredAuthentications", "publickey"); if (hostInfo.isDoHostKeyChecks()) { jSch.setKnownHosts(userInfo.sshFolderLocation() + File.separator + "known_hosts"); } else { jSch.setHostKeyRepository(new FakeHostKeyRepository()); } if (userInfo.isUseAgentIdentities()) { Connector connector = ConnectorFactory.getDefault().createConnector(); if (connector != null) { IdentityRepository identityRepository = new RemoteIdentityRepository(connector); jSch.setIdentityRepository(identityRepository); } } // add private key to the IdentityRepository. If using agent identities, this will add the private // key to the agent, if it is not already present. jSch.addIdentity(userInfo.privateKeyLocation().getAbsolutePath()); session = jSch.getSession(userInfo.getUserName(), hostInfo.getHostname(), hostInfo.getPort()); Long timeout = TimeUnit.SECONDS.toMillis(hostInfo.getTimeoutSeconds()); session.setTimeout(timeout.intValue()); session.setUserInfo(new PasswordlessEnabledUser(userInfo.getPassphrase())); return session; } catch (JSchException | AgentProxyException e) { String msg = ExecutionFailedException.userFriendlyCause(e.getMessage(), hostInfo.getHostname(), userInfo); throw new ExecutionFailedException(msg, e); } }
public RemoteClient(Environment environment, DeploymentContext context, Logger logger) throws RemoteClientException { RemoteClient instance = this; Runtime.getRuntime().addShutdownHook(new Thread() { public void run() { instance.tryDisconnect(); } }); this.logger = logger; try { JSch shellClient = new JSch(); shellClient.setKnownHosts(new FileInputStream(new File(System.getenv("HOME") + "/.ssh/known_hosts"))); ConnectorFactory connectorFactory = ConnectorFactory.getDefault(); Connector connector = connectorFactory.createConnector(); Properties config = new java.util.Properties(); config.put("PreferredAuthentications", "publickey"); if (context.project().options().containsKey("check_host_keys")) { String option = (boolean) context.project().options().get("check_host_keys") ? "yes" : "no"; JSch.setConfig("StrictHostKeyChecking", option); if (option.equals("no")) { logger.warn("WARNING: host key check is disabled!"); } } if (connector != null) { IdentityRepository remoteIdentityRepository = new RemoteIdentityRepository(connector); shellClient.setIdentityRepository(remoteIdentityRepository); } for (Target target : environment.targets()) { sessions.add(new RemoteTarget(connect(shellClient, target, context, config), target, context, environment)); } } catch (AgentProxyException | FileNotFoundException | JSchException e) { throw new RemoteClientException(e.getMessage()); } }
@Nullable private static Connector createSshAgentConnector() { Connector result = null; try { result = ConnectorFactory.getDefault().createConnector(); } catch (AgentProxyException e) { LOG.info("Could not create ssh agent connector", e); } return result; }
private Session initSessionSshAgent(String username, String socketPath, JSch jsch) throws JSchException { final Session session = jsch.getSession(username, myHost, myPort); session.setConfig("PreferredAuthentications", "publickey"); try { ConnectorFactory cf = ConnectorFactory.getDefault(); cf.setUSocketPath(socketPath); Connector con = cf.createConnector(); IdentityRepository irepo = new RemoteIdentityRepository(con); jsch.setIdentityRepository(irepo); return session; } catch (AgentProxyException e) { throw new JSchException("Failed to connect to ssh agent.", e); } }
/** * Attempts to connect to a local SSH agent (using either UNIX sockets or PuTTY's Pageant) * * @param jsch * Connection to be attached to an available local agent * @return true if connected to agent, false otherwise */ private boolean attemptAgentUse(JSch jsch) { try { Connector con = ConnectorFactory.getDefault().createConnector(); jsch.setIdentityRepository(new RemoteIdentityRepository(con)); return true; } catch (Exception e) { Message.verbose(":: SSH :: Failure connecting to agent :: " + e.toString()); return false; } }
public static SshClient.Factory defaultSshClientFactory() { return new SshClient.Factory() { int timeout = SystemUtils2.getIntegerProperty("org.excalibur.ssh.default.connection.timeout.ms", 60000); Optional<Connector> agentConnector = getAgentConnector(); @Override public boolean isAgentAvailable() { return agentConnector.isPresent(); } @Override public SshClient create(HostAndPort socket, LoginCredentials credentials) { return new JschSshClient(socket, credentials, timeout, agentConnector, new BackoffLimitedRetryHandler()); } Optional<Connector> getAgentConnector() { try { return Optional.of(ConnectorFactory.getDefault().createConnector()); } catch (final AgentProxyException e) { return Optional.absent(); } } }; }
private SshConnection(HostAndPort hostAndPort, LoginCredentials loginCredentials, Optional<Proxy> proxy, int connectTimeout, int sessionTimeout, Optional<Connector> agentConnector) { this.hostAndPort_ = checkNotNull(hostAndPort); this.loginCredentials_ = checkNotNull(loginCredentials, " login for %s", hostAndPort); this.proxy_ = checkNotNull(proxy, " proxy for %s", hostAndPort); this.connectTimeout_ = checkNotNull(connectTimeout); this.sessionTimeout_ = checkNotNull(sessionTimeout); this.agentConnector_ = checkNotNull(agentConnector, "agent connector for %s", hostAndPort); }
public IdentityRepositoryImpl (Connector connector) { this.connector = connector; this.proxy = new AgentProxy(connector); }
/** * @return the agentConnector */ public Optional<Connector> getAgentConnector() { return agentConnector_; }