protected void connectSession() throws JSchException {
if (session != null) {
if (session.isConnected()) {
session.disconnect();
}
session = null;
}
AutomationLogger.getInstance().info("Connectting...");
if (StringUtil.notEmpty(user)) {
session = jsch.getSession(user, host, 22);
session.setPassword(password);
} else if (auth != null) {
session = auth.getSession(host);
} else {
throw new ItemNotFoundException("Authentication is missing!");
}
java.util.Properties config = new java.util.Properties();
config.put("StrictHostKeyChecking", "no");
session.setConfig(config);
session.connect();
AutomationLogger.getInstance().info("Connected");
}
static boolean getConnection(String username, String password, String host, int port) {
try {
JSch jsch = new JSch();
session = jsch.getSession(username, host, port);
UserInfo ui = new MyUserInfo();
session.setUserInfo(ui);
MyUserInfo temp = (MyUserInfo) ui;
temp.setPassword(password);
session.connect();
Channel channel = session.openChannel("sftp");
channel.connect();
SFTPFileLoader.sftpChannel = (ChannelSftp) channel;
return true;
} catch (Exception e) {
System.out.println(e);
errorMessage += e.toString();
}
return false;
}
private void init() {
otherHostInfo = getOtherHostInfo();
JSch jSch = new JSch();
java.util.Properties config = new java.util.Properties();
config.put("StrictHostKeyChecking", "no");
try {
session = jSch.getSession(hostInfo.getUser(), hostInfo.getIp(), hostInfo.getPort());
session.setConfig(config);
session.setPassword(hostInfo.getPassword());
session.connect(5000);
System.out.println(hostInfo.getIp() + "已连接...");
channel = session.openChannel("shell");
channel.connect();
expect =
new ExpectBuilder()
.withOutput(channel.getOutputStream())
.withInputs(channel.getInputStream(), channel.getExtInputStream())
.withEchoInput(System.out)
.withEchoOutput(System.err)
.withInputFilters(removeColors(), removeNonPrintable())
.withExceptionOnFailure()
.withTimeout(80000, TimeUnit.SECONDS)
.withAutoFlushEcho(true)
.withCombineInputs(true)
.build();
System.out.println(expect.getClass().getName());
} catch (JSchException | IOException e) {
e.printStackTrace();
destroy();
throw new RuntimeException("无法连接" + hostInfo.getIp() + ":" + hostInfo.getPort());
}
}
/**
* This will execute the given command with given session and session is not closed at the end.
*
* @param commandInfo
* @param session
* @param commandOutput
* @throws SSHApiException
*/
public static Session executeCommand(
CommandInfo commandInfo, Session session, CommandOutput commandOutput)
throws SSHApiException {
String command = commandInfo.getCommand();
Channel channel = null;
try {
if (!session.isConnected()) {
session.connect();
}
channel = session.openChannel("exec");
((ChannelExec) channel).setCommand(command);
} catch (JSchException e) {
session.disconnect();
throw new SSHApiException("Unable to execute command - ", e);
}
channel.setInputStream(null);
((ChannelExec) channel).setErrStream(commandOutput.getStandardError());
try {
channel.connect();
} catch (JSchException e) {
channel.disconnect();
session.disconnect();
throw new SSHApiException("Unable to retrieve command output. Command - " + command, e);
}
commandOutput.onOutput(channel);
// Only disconnecting the channel, session can be reused
channel.disconnect();
return session;
}
@Override
public void afterPropertiesSet() {
jsch = new JSch();
if (!isConnected) {
if (null == session || !session.isConnected()) {
try {
session = jsch.getSession(sshUsername, host, port);
session.setPassword(sshPassword);
java.util.Properties config = new java.util.Properties();
config.put("StrictHostKeyChecking", "no");
session.setConfig(config);
log.info("Открытие ssh соединения");
session.connect();
log.info("Tunnel status: " + session.isConnected());
log.info("Устанавливаем туннель");
session.setPortForwardingL(tunnelLocalPort, tunnelRemoteHost, tunnelRemotePort);
} catch (Exception e) {
log.error("Ошибка при построении соединения", e);
System.exit(1);
}
}
isConnected = true;
}
}
private static void sftpUpload() {
JSch.setLogger(new JschLogger());
Session session = null;
try {
JSch jsch = new JSch();
session = jsch.getSession(USERNAME, HOST, PORT);
session.setPassword(PASSWORD);
Properties config = new Properties();
config.put("StrictHostKeyChecking", "no");
session.setConfig(config);
session.connect();
Channel channel = session.openChannel(PROTOCOL_SFTP);
channel.connect();
BufferedInputStream in = new BufferedInputStream(new FileInputStream(SOURCE));
ChannelSftp channelSftp = (ChannelSftp) channel;
channelSftp.cd(TARGET);
channelSftp.put(in, FILE_NAME);
} catch (JSchException | SftpException | FileNotFoundException ex) {
Logger.getLogger(JschDemo.class.getName()).log(Level.SEVERE, null, ex);
} finally {
if (session != null) {
session.disconnect();
}
}
}
@Test
public void testDontConnectSftpIfNoSourceFilesInAnyTransfers() throws Exception {
final BapSshCommonConfiguration defaultKeyInfo =
new BapSshCommonConfiguration(TEST_PASSPHRASE, null, null, false);
hostConfig = createWithDefaultKeyInfo(mockJSch, defaultKeyInfo);
final BapSshTransfer transfer1 =
new BapSshTransfer(
"", "", "", "", false, false, "ls -la", 10000, false, false, false, null);
final BapSshTransfer transfer2 =
new BapSshTransfer("", "", "", "", false, false, "pwd", 10000, false, false, false, null);
final ArrayList<BapSshTransfer> transfers = new ArrayList<BapSshTransfer>();
transfers.addAll(Arrays.asList(transfer1, transfer2));
final BapSshPublisher publisher =
new BapSshPublisher(
getHostConfig().getName(), false, transfers, false, false, null, null, null);
expect(
mockJSch.getSession(
getHostConfig().getUsername(),
getHostConfig().getHostname(),
getHostConfig().getPort()))
.andReturn(mockSession);
mockSession.setPassword(defaultKeyInfo.getPassphrase());
mockSession.setConfig((Properties) anyObject());
mockSession.connect(getHostConfig().getTimeout());
mockControl.replay();
getHostConfig().createClient(buildInfo, publisher);
mockControl.verify();
}
private void runJschTest(int port) throws Exception {
JSchLogger.init();
JSch sch = new JSch();
JSch.setConfig("cipher.s2c", CRYPT_NAMES);
JSch.setConfig("cipher.c2s", CRYPT_NAMES);
com.jcraft.jsch.Session s = sch.getSession(getCurrentTestName(), "localhost", port);
s.setUserInfo(new SimpleUserInfo(getCurrentTestName()));
s.connect();
try {
com.jcraft.jsch.Channel c = s.openChannel("shell");
c.connect();
try (OutputStream os = c.getOutputStream();
InputStream is = c.getInputStream()) {
String expected = "this is my command\n";
byte[] expData = expected.getBytes(StandardCharsets.UTF_8);
byte[] actData = new byte[expData.length + Long.SIZE /* just in case */];
for (int i = 0; i < 10; i++) {
os.write(expData);
os.flush();
int len = is.read(actData);
String actual = new String(actData, 0, len);
assertEquals("Mismatched command at iteration " + i, expected, actual);
}
} finally {
c.disconnect();
}
} finally {
s.disconnect();
}
}
/* (non-Javadoc)
* @see net.sf.thingamablog.transport.PublishTransport#connect()
*/
public boolean connect() {
failMsg = "";
if (isConnected) {
failMsg = "Already connected";
return false;
}
try {
JSch jsch = new JSch();
Session session = jsch.getSession(getUserName(), getAddress(), getPort());
// password will be given via UserInfo interface.
UserInfo ui = new MyUserInfo(getPassword());
session.setUserInfo(ui);
logger.info("Connecting to SFTP");
session.connect();
logger.info("Logged in to SFTP");
Channel channel = session.openChannel("sftp");
channel.connect();
sftp = (ChannelSftp) channel;
isConnected = true;
return true;
} catch (Exception ex) {
failMsg = "Error logging in to " + getAddress();
failMsg += "\n" + ex.getMessage();
logger.log(Level.WARNING, failMsg, ex);
ex.printStackTrace();
}
return false;
}
@Test
public void testCreateClientFailsIfPwdReturnsRelativePath() throws Exception {
final String remoteRoot = "some/directory/in/my/home/dir";
hostConfig = createWithOverrideUsernameAndPassword(mockJSch);
getHostConfig().setRemoteRootDir(remoteRoot);
final BapSshCommonConfiguration commonConfiguration =
new BapSshCommonConfiguration("Ignore me", null, null, false);
getHostConfig().setCommonConfig(commonConfiguration);
expect(
mockJSch.getSession(
getHostConfig().getUsername(),
getHostConfig().getHostname(),
getHostConfig().getPort()))
.andReturn(mockSession);
mockSession.setPassword(TEST_PASSPHRASE);
mockSession.setConfig((Properties) anyObject());
mockSession.connect(getHostConfig().getTimeout());
expect(mockSession.openChannel("sftp")).andReturn(mockSftp);
mockSftp.connect(getHostConfig().getTimeout());
testHelper.expectDirectoryCheck(getHostConfig().getRemoteRootDir(), true);
mockSftp.cd(getHostConfig().getRemoteRootDir());
expect(mockSftp.pwd()).andReturn("home/bap/" + remoteRoot);
expect(mockSftp.isConnected()).andReturn(false);
expect(mockSession.isConnected()).andReturn(false);
assertCreateClientThrowsException("home/bap/" + remoteRoot);
}
@Test
public void testCreateClientWillUseKeyIfKeyAndKeyPathPresent() throws Exception {
final String testKey = "MyVeryBigKey";
final BapSshCommonConfiguration defaultKeyInfo =
new BapSshCommonConfiguration(
TEST_PASSPHRASE, testKey, "/this/file/will/not/be/used", false);
hostConfig = createWithDefaultKeyInfo(mockJSch, defaultKeyInfo);
getHostConfig().setPassword("Ignore me");
expect(
mockJSch.getSession(
getHostConfig().getUsername(),
getHostConfig().getHostname(),
getHostConfig().getPort()))
.andReturn(mockSession);
mockJSch.addIdentity(
isA(String.class),
aryEq(BapSshUtil.toBytes(testKey)),
(byte[]) isNull(),
aryEq(BapSshUtil.toBytes(TEST_PASSPHRASE)));
mockSession.setConfig((Properties) anyObject());
mockSession.connect(getHostConfig().getTimeout());
expect(mockSession.openChannel("sftp")).andReturn(mockSftp);
mockSftp.connect(getHostConfig().getTimeout());
testHelper.expectDirectoryCheck(getHostConfig().getRemoteRootDir(), true);
mockSftp.cd(getHostConfig().getRemoteRootDir());
assertCreateClient();
}
@Test
public void testCreateClientWithOverrideKeyPath() throws Exception {
final String testKeyFilename = "myPrivateKey";
final RandomFile theKey = new RandomFile(jenkinsHome.getRoot(), testKeyFilename);
hostConfig =
createWithOverrideUsernameAndPassword(mockJSch, TEST_PASSPHRASE, testKeyFilename, "");
final BapSshCommonConfiguration commonConfiguration =
new BapSshCommonConfiguration("Ignore me", null, null, false);
getHostConfig().setCommonConfig(commonConfiguration);
expect(
mockJSch.getSession(
getHostConfig().getUsername(),
getHostConfig().getHostname(),
getHostConfig().getPort()))
.andReturn(mockSession);
mockJSch.addIdentity(
isA(String.class),
aryEq(theKey.getContents()),
(byte[]) isNull(),
aryEq(BapSshUtil.toBytes(TEST_PASSPHRASE)));
mockSession.setConfig((Properties) anyObject());
mockSession.connect(getHostConfig().getTimeout());
expect(mockSession.openChannel("sftp")).andReturn(mockSftp);
mockSftp.connect(getHostConfig().getTimeout());
testHelper.expectDirectoryCheck(getHostConfig().getRemoteRootDir(), true);
mockSftp.cd(getHostConfig().getRemoteRootDir());
assertCreateClient();
}
private BapSshClient assertCreateClientWithDefaultKey(final boolean disableExec)
throws Exception {
final String testKey = "MyVeryBigKey";
final BapSshCommonConfiguration defaultKeyInfo =
new BapSshCommonConfiguration(TEST_PASSPHRASE, testKey, null, disableExec);
hostConfig = createWithDefaultKeyInfo(mockJSch, defaultKeyInfo);
getHostConfig().setPassword("Ignore me");
expect(
mockJSch.getSession(
getHostConfig().getUsername(),
getHostConfig().getHostname(),
getHostConfig().getPort()))
.andReturn(mockSession);
mockJSch.addIdentity(
isA(String.class),
aryEq(BapSshUtil.toBytes(testKey)),
(byte[]) isNull(),
aryEq(BapSshUtil.toBytes(defaultKeyInfo.getPassphrase())));
mockSession.setConfig((Properties) anyObject());
mockSession.connect(getHostConfig().getTimeout());
expect(mockSession.openChannel("sftp")).andReturn(mockSftp);
mockSftp.connect(getHostConfig().getTimeout());
testHelper.expectDirectoryCheck(getHostConfig().getRemoteRootDir(), true);
mockSftp.cd(getHostConfig().getRemoteRootDir());
return assertCreateClient();
}
public static void main(String[] arg) throws JSchException, InterruptedException {
JSch jsch = new JSch();
String[] proxyInfo = queryUserAndHost("proxy server", arg.length > 0 ? arg[0] : null);
Session gateway = jsch.getSession(proxyInfo[0], proxyInfo[1]);
UserInfo ui = new SwingDialogUserInfo();
gateway.setUserInfo(ui);
gateway.connect();
String[] targetInfo = queryUserAndHost("target server", arg.length > 1 ? arg[1] : null);
Session session = jsch.getSession(targetInfo[0], targetInfo[1]);
session.setProxy(new ProxySSH(gateway));
session.setUserInfo(ui);
System.err.println("connecting session ...");
session.connect();
System.err.println("session connected.");
System.err.println("opening shell channel ...");
Channel channel = session.openChannel("shell");
channel.setOutputStream(System.out, true);
channel.setExtOutputStream(System.err, true);
channel.setInputStream(System.in, true);
channel.connect();
System.err.println("shell channel connected.");
do {
Thread.sleep(100);
} while (!channel.isEOF());
System.err.println("exitcode: " + channel.getExitStatus());
session.disconnect();
Thread.sleep(50);
gateway.disconnect();
}
/**
* 连接到指定的IP
*
* @throws JSchException
*/
public void connect() throws JSchException {
jsch = new JSch();
session = jsch.getSession(user, host, 22);
session.setPassword(passwd);
java.util.Properties config = new java.util.Properties();
config.put("StrictHostKeyChecking", "no");
session.setConfig(config);
session.connect();
}
public void login(String username, String password) throws JSchException {
session = jSch.getSession(username, ip, port);
session.setPassword(password);
//// FIXME: 03/04/2016 Security
session.setConfig("StrictHostKeyChecking", "no");
session.connect();
channel = (ChannelSftp) session.openChannel("sftp");
channel.connect();
}
@Override
protected Integer doInBackground(String... arg0) {
StrictMode.ThreadPolicy policy = new StrictMode.ThreadPolicy.Builder().permitAll().build();
StrictMode.setThreadPolicy(policy);
Thread.currentThread().setName("SSHConnectionThread");
try {
JSch jsch = new JSch();
session = jsch.getSession(arg0[1], arg0[0], 22);
session.setPassword(arg0[2].getBytes());
session.setConfig("StrictHostKeyChecking", "no");
session.connect(timeout);
System.out.println("connesso? " + session.isConnected());
int assinged_port = session.setPortForwardingL(lhost, lport, rhost, rport);
session.setPortForwardingL(lhost, 9001, rhost, 502);
System.out.println("localhost:" + assinged_port + " -> " + rhost + ":" + rport);
ConnectionManager.setSession(session);
} catch (Exception e) {
// System.out.println(e.getLocalizedMessage());
// String errore = "";
// if(e instanceof JSchException) errore = "Errore SSH ";
// else if(e instanceof UnknownHostException) errore = "Ricontrolla il dominio o la
// connessione internet, cè qualcosa di errato, attento agli spazi e maiscole";
// else if(e instanceof ConnectException) errore = "Ricontrolla i campi o la connessione cè
// qualcosa che non va, attento agli spazi e maiscole";
// else errore = "Ricontrolla user, password e dominio, cè qualcosa di errato, attento agli
// spazi e maiscole";
// if(isDialogActivated()){
// AlertMessageTask errorConnection = new AlertMessageTask();
// errorConnection.setActivity(getActivity());
// errorConnection.execute(errore);
// }
if (fireEvent && !e.getLocalizedMessage().contains("PortForwardingL:")) {
System.out.println("non è portforwarding ma " + e.getLocalizedMessage());
if (MainActivity.handle == null) return null;
Message msgObj = MainActivity.handle.obtainMessage();
Bundle ba = new Bundle();
ba.putInt("status", 0);
msgObj.setData(ba);
MainActivity.handle.sendMessage(msgObj);
fireEvent = false;
}
return null;
}
if (fireEvent) {
if (MainActivity.handle == null) return null;
Message msgObj = MainActivity.handle.obtainMessage();
Bundle ba = new Bundle();
ba.putInt("status", 1);
msgObj.setData(ba);
MainActivity.handle.sendMessage(msgObj);
fireEvent = false;
}
return null;
};
@Override
public void send(String path, String filename, Binary content) throws IOException {
Session session = null;
Channel channel = null;
ChannelSftp channelSftp = null;
logger.debug("preparing the host information for sftp.");
InputStream data = null;
try {
JSch jsch = new JSch();
session = jsch.getSession(this.username, this.server, this.remotePort);
if (this.password != null) {
session.setPassword(this.password);
}
java.util.Properties config = new java.util.Properties();
config.put("StrictHostKeyChecking", "no");
session.setConfig(config);
session.connect();
logger.debug("Host connected.");
channel = session.openChannel("sftp");
channel.connect();
logger.debug("sftp channel opened and connected.");
channelSftp = (ChannelSftp) channel;
if (path != null) {
channelSftp.cd(path);
}
File f = new File(filename);
data = content.getDataAsStream();
channelSftp.put(data, f.getName());
logger.info("File transfered successfully to host.");
} catch (Exception ex) {
throw new IOException("SFTP problem", ex);
} finally {
if (data != null) {
try {
data.close();
} catch (IOException e) {
}
}
if (channelSftp != null) {
channelSftp.exit();
}
logger.info("sftp Channel exited.");
if (channel != null) {
channel.disconnect();
}
logger.info("Channel disconnected.");
if (session != null) {
session.disconnect();
}
logger.info("Host Session disconnected.");
}
}
@BeforeClass(alwaysRun = true)
public void initServer() throws JSchException {
testDataCreator.create();
sshServer.start();
final JSch jsch = new JSch();
session = jsch.getSession("admin", "localhost", SshServerWrapper.DEFAULT_PORT);
final java.util.Properties config = new java.util.Properties();
config.put("StrictHostKeyChecking", "no");
session.setConfig(config);
session.setPassword("admin");
session.connect();
}
@Override
public void start() throws MachineException {
try {
session = jsch.getSession(username, host, port);
session.setUserInfo(user);
// todo remember parent pid of shell to be able to kill all processes on client stop
if (!session.isConnected()) {
session.connect(connectionTimeout);
}
} catch (JSchException e) {
throw new MachineException(
"Ssh machine creation failed because ssh of machine is inaccessible. Error: "
+ e.getLocalizedMessage());
}
}
/**
* Open an ssh seession.
*
* @return the opened session
* @throws JSchException on error
*/
protected Session openSession() throws JSchException {
JSch jsch = new JSch();
if (null != userInfo.getKeyfile()) {
jsch.addIdentity(userInfo.getKeyfile());
}
if (!userInfo.getTrust() && knownHosts != null) {
project.log("Using known hosts: " + knownHosts, Project.MSG_DEBUG);
jsch.setKnownHosts(knownHosts);
}
Session session = jsch.getSession(userInfo.getName(), host, port);
session.setUserInfo(userInfo);
project.log("Connecting to " + host + ":" + port, Project.MSG_VERBOSE);
session.connect();
return session;
}
public void push(String user, String server, File f, String to) {
file = f;
if (ssh == null)
try {
ssh = jsch.getSession(user, server, 22);
UserInfo ui = new SSHUserInfo();
ssh.setUserInfo(ui);
ssh.setConfig("StrictHostKeyChecking", "no");
ssh.setPortForwardingL(28947, "127.0.0.1", 28947);
ssh.connect();
} catch (JSchException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Thread t = new Thread(this);
t.start();
}
public static void main(String[] arg) {
String xhost = "127.0.0.1";
int xport = 0;
try {
JSch jsch = new JSch();
String host = null;
if (arg.length > 0) {
host = arg[0];
} else {
host =
JOptionPane.showInputDialog(
"Enter username@hostname", System.getProperty("user.name") + "@localhost");
}
String user = host.substring(0, host.indexOf('@'));
host = host.substring(host.indexOf('@') + 1);
Session session = jsch.getSession(user, host, 22);
String display =
JOptionPane.showInputDialog("Please enter display name", xhost + ":" + xport);
xhost = display.substring(0, display.indexOf(':'));
xport = Integer.parseInt(display.substring(display.indexOf(':') + 1));
session.setX11Host(xhost);
session.setX11Port(xport + 6000);
// username and password will be given via UserInfo interface.
UserInfo ui = new MyUserInfo();
session.setUserInfo(ui);
session.connect();
Channel channel = session.openChannel("shell");
channel.setXForwarding(true);
channel.setInputStream(System.in);
channel.setOutputStream(System.out);
channel.connect();
} catch (Exception e) {
System.out.println(e);
}
}
/**
* @param userName the name of the account being logged into.
* @param hostName this should be the host. I found values like <code>foo.com</code> work, where
* <code>http://foo.com</code> don't.
* @param userPassword if you are not using key based authentication, then you are likely being
* prompted for a password each time you login. This is that password. It is <em>not</em> the
* passphrase for the private key!
* @param port the default is 22, and if you specify N<0 for this value we'll default it to 22
* @param knownHostsFile this is the known hosts file. If you don't specify it, jsch does some
* magic to work without your specification. If you have it in a non well-known location,
* however, this property is for you. An example: <code>/home/user/.ssh/known_hosts</code>
* @param knownHostsInputStream this is the known hosts file. If you don't specify it, jsch does
* some magic to work without your specification. If you have it in a non well-known location,
* however, this property is for you. An example: <code>/home/user/.ssh/known_hosts</code>.
* Note that you may specify this <em>or</em> the #knownHostsFile - not both!
* @param privateKey this is usually used when you want passwordless automation (obviously, for
* this integration it's useless since this lets you specify a password once, anyway, but
* still good to have if required). This file might be ~/.ssh/id_dsa, or a <code>.pem</code>
* for your remote server (for example, on EC2)
* @param pvKeyPassPhrase sometimes, to be extra secure, the private key itself is extra
* encrypted. In order to surmount that, we need the private key passphrase. Specify that
* here.
* @throws Exception thrown if any of a myriad of scenarios plays out
*/
public SftpSession(
String userName,
String hostName,
String userPassword,
int port,
String knownHostsFile,
InputStream knownHostsInputStream,
String privateKey,
String pvKeyPassPhrase)
throws Exception {
JSch jSch = new JSch();
if (port <= 0) {
port = 22;
}
this.privateKey = privateKey;
this.privateKeyPassphrase = pvKeyPassPhrase;
if (!StringUtils.isEmpty(knownHostsFile)) {
jSch.setKnownHosts(knownHostsFile);
} else if (null != knownHostsInputStream) {
jSch.setKnownHosts(knownHostsInputStream);
}
// private key
if (!StringUtils.isEmpty(this.privateKey)) {
if (!StringUtils.isEmpty(privateKeyPassphrase)) {
jSch.addIdentity(this.privateKey, privateKeyPassphrase);
} else {
jSch.addIdentity(this.privateKey);
}
}
session = jSch.getSession(userName, hostName, port);
if (!StringUtils.isEmpty(userPassword)) {
session.setPassword(userPassword);
}
userInfo = new OptimisticUserInfoImpl(userPassword);
session.setUserInfo(userInfo);
session.connect();
channel = (ChannelSftp) session.openChannel("sftp");
}
@Test
public void testFailToConnect() throws Exception {
hostConfig = createWithOverrideUsernameAndPassword(mockJSch);
getHostConfig().setCommonConfig(new BapSshCommonConfiguration("", "", "", false));
expect(
mockJSch.getSession(
getHostConfig().getUsername(),
getHostConfig().getHostname(),
getHostConfig().getPort()))
.andReturn(mockSession);
mockSession.setPassword(TEST_PASSPHRASE);
mockSession.setConfig((Properties) anyObject());
final JSchException exception = new JSchException("meh");
mockSession.connect(getHostConfig().getTimeout());
expectLastCall().andThrow(exception);
expect(mockSession.isConnected()).andReturn(false);
assertCreateClientThrowsException(exception);
}
@Override
public Session create() throws Exception {
JSch jsch = new JSch();
session =
jsch.getSession(
loginCredentials.getUser(),
hostAndPort.getHostText(),
hostAndPort.getPortOrDefault(22));
if (sessionTimeout != 0) session.setTimeout(sessionTimeout);
if (loginCredentials.getPrivateKey() == null) {
session.setPassword(loginCredentials.getPassword());
} else {
byte[] privateKey = loginCredentials.getPrivateKey().getBytes();
if (CredentialUtils.isPrivateKeyEncrypted(privateKey)) {
throw new IllegalArgumentException(
"JschSshClientModule does not support private keys that require a passphrase");
}
jsch.addIdentity(
loginCredentials.getUser(),
Arrays.copyOf(privateKey, privateKey.length),
null,
emptyPassPhrase);
}
java.util.Properties config = new java.util.Properties();
config.put("StrictHostKeyChecking", "no");
session.setConfig(config);
session.connect(connectTimeout);
return session;
}
private Session connectToInstance(String publicDNS) throws Exception {
JSch jsch = new JSch();
jsch.addIdentity("rtp.pem");
Session session = jsch.getSession("ubuntu", publicDNS);
Properties config = new Properties();
config.put("StrictHostKeyChecking", "no");
session.setConfig(config);
session.connect();
return session;
}
public void openSshConnection() throws JSchException {
JSch jSch = new JSch();
if (privateKeyLocation != null) {
session = jSch.getSession(username, destinationHost, connectionPort);
jSch.addIdentity(privateKeyLocation);
} else {
session = jSch.getSession(username, destinationHost, connectionPort);
session.setPassword(password);
}
session.setConfig("StrictHostKeyChecking", "no");
session.setConfig(
"PreferredAuthentications",
"publickey,keyboard-interactive,password"); // Skipping kerberos authentication
session.connect(SLEEP_MILLISECONDS);
}
/**
* method for establishing connection while authentication
*
* @param username
* @param namenodeIP
* @param nnpwd
* @param privateKeyPath
* @return
* @throws JSchException
* @throws IOException
* @throws InterruptedException
*/
public static Session establishConnection(
String username, String namenodeIP, String nnpwd, String privateKeyPath)
throws JSchException, IOException, InterruptedException {
JSch jsch = new JSch();
Session session = jsch.getSession(username, namenodeIP, Constants.TWENTY_TWO);
session.setPassword(nnpwd);
UserInfo info = new JumbuneUserInfo();
jsch.addIdentity(privateKeyPath, nnpwd);
session.setUserInfo(info);
java.util.Properties config = new java.util.Properties();
config.put("StrictHostKeyChecking", "no");
session.setConfig(config);
session.connect();
return session;
}
public static void main(String[] arg) {
try {
JSch jsch = new JSch();
String user = "******";
String host = "hddev-c01-edge-01";
int port = 22;
String privateKey = "src/main/resources/id_rsa";
jsch.addIdentity(privateKey);
System.out.println("identity added ");
Session session = jsch.getSession(user, host, port);
System.out.println("session created.");
// disabling StrictHostKeyChecking may help to make connection but makes it insecure
// see
// http://stackoverflow.com/questions/30178936/jsch-sftp-security-with-session-setconfigstricthostkeychecking-no
//
java.util.Properties config = new java.util.Properties();
config.put("StrictHostKeyChecking", "no");
session.setConfig(config);
session.connect();
System.out.println("session connected.....");
Channel channel = session.openChannel("sftp");
channel.setInputStream(System.in);
channel.setOutputStream(System.out);
channel.connect();
System.out.println("shell channel connected....");
ChannelSftp c = (ChannelSftp) channel;
String fileName = "src/main/resources/test.txt";
c.put(fileName, "./in/");
c.exit();
System.out.println("done");
} catch (Exception e) {
System.err.println(e);
}
}
