import com.sshtools.j2ssh.transport.IgnoreHostKeyVerification; //导入依赖的package包/类
/**
 * connect to host
 * 
 * @return
 * @throws Exception
 */
private static SshClient connectSsh() throws Exception {
	SshClient ssh = new SshClient();

	HostKeyVerification host = new IgnoreHostKeyVerification();
	String hostStr = getBundle().getString("ssh.host");
	ssh.connect(hostStr, host);
	PasswordAuthenticationClient auth = new PasswordAuthenticationClient();
	auth.setUsername(getBundle().getString("ssh.user"));
	auth.setPassword(getBundle().getString("ssh.pwd"));
	int result = ssh.authenticate(auth);

	System.out.println("Status " + result);
	if ((result == AuthenticationProtocolState.CANCELLED) || (result == AuthenticationProtocolState.FAILED)) {
		throw new Exception("Authentication Error.");
	}
	return ssh;
}
 

import com.sshtools.j2ssh.transport.IgnoreHostKeyVerification; //导入依赖的package包/类
public boolean connect(String host, String user, String password) {		
	try {
		// Connect to host ignoring host key verification
		ssh.connect(host, new IgnoreHostKeyVerification());
		
		PasswordAuthenticationClient pwd = new PasswordAuthenticationClient();
		pwd.setUsername(user);
		pwd.setPassword(password);
		
		status = ssh.authenticate(pwd);
		
		if (status == AuthenticationProtocolState.COMPLETE)
			return true;
		else
			return false;			
	} catch (IOException ioe) {
		System.out.println("Error in connecting to "+host+" with user "+user);
		return false;			
	}		
}
 

import com.sshtools.j2ssh.transport.IgnoreHostKeyVerification; //导入依赖的package包/类
/***********************************************************************/
public synchronized Connection makeConnection(String database, DatabaseConfiguration originalConfiguration)
{
  int port = counter++;
  DatabaseConfiguration config = new DatabaseConfiguration(originalConfiguration.getDataSourceName(), originalConfiguration.getDriver(), originalConfiguration.getProtocol(), "localhost", "" + port, database, originalConfiguration.getUserName(), originalConfiguration.getPassword(), originalConfiguration.getType());
  try
  {
      LogFactory.getFactory().setAttribute("org.apache.commons.logging.Log", "org.apache.commons.logging.impl.NoOpLog");
      SshClient ssh = new SshClient();
      ssh.setSocketTimeout(60000);
      ssh.connect(originalConfiguration.getServer(), new IgnoreHostKeyVerification());
      PasswordAuthenticationClient pwd = new PasswordAuthenticationClient();
      pwd.setUsername(originalConfiguration.getUserName());
      pwd.setPassword(originalConfiguration.getPassword());
      ssh.authenticate(pwd);
      ForwardingClient client = ssh.getForwardingClient();
      client.addLocalForwarding(config.getProtocol(), "0.0.0.0", config.getPort(), "localhost", originalConfiguration.getPort());
      client.startLocalForwarding(config.getProtocol());
      return new SshConnection(ssh, config.makeConnection());
  }
  catch (IOException ie)
  {
    throw ObjectUtils.throwAsError(ie);
  }
}
 

import com.sshtools.j2ssh.transport.IgnoreHostKeyVerification; //导入依赖的package包/类
public boolean connectKey(String host, String user, String keyFile) {		
	try {
		// Connect to host ignoring host key verification
		ssh.connect(host, new IgnoreHostKeyVerification());
		
		PublicKeyAuthenticationClient sshClient = new PublicKeyAuthenticationClient();

		SshPrivateKeyFile sshPrivKeyFile = SshPrivateKeyFile.parse(new File(keyFile));
		
		SshPrivateKey sshPrivKey = null;
		try {
			sshPrivKey = sshPrivKeyFile.toPrivateKey("");
		} catch (InvalidSshKeyException iske) {
			System.out.println("Wrong key or unsupported usage of passphrase.");
			return false;
		}
		sshClient.setKey(sshPrivKey);
		sshClient.setUsername(user);
		
		status = ssh.authenticate(sshClient);
		
		if (status == AuthenticationProtocolState.COMPLETE)
			return true;
		else
			return false;			
	} catch (IOException ioe) {
		System.out.println("Error in connecting to "+host+" with keyfile "+keyFile);
		System.out.println(ioe);
		return false;			
	}		
}
 

import com.sshtools.j2ssh.transport.IgnoreHostKeyVerification; //导入依赖的package包/类
/**
 * Connect. This action simulates all the actions required for a SSH connection
 *
 * @param host  the hostname of the host you want to connect to
 * @param port the port of the host you want to connect to
 * @param username the username required for authentication
 * @param password the password required for authentication
 * @return the ssh client you connected to
 * @throws IOException Signals that an I/O exception has occurred.
 */
public static SshClient connect(String host, int port,String username,String password) throws IOException {
	SSH_LOG.info("Connecting to " + host);
	SshClient ssh = new SshClient();
	ssh.connect(host, port, new IgnoreHostKeyVerification());
	PasswordAuthenticationClient passwordAuthenticationClient = new PasswordAuthenticationClient();
	passwordAuthenticationClient.setUsername(username);
	passwordAuthenticationClient.setPassword(password);
	int result = ssh.authenticate(passwordAuthenticationClient);
	if (result != AuthenticationProtocolState.COMPLETE) {
		throw new IOException("Login to " + host + ":" + port + " "+ username + "/" + password + " failed");
	}
	SSH_LOG.info("Connected " + host);
	return ssh;
}
 

import com.sshtools.j2ssh.transport.IgnoreHostKeyVerification; //导入依赖的package包/类
/************************************************************************/
private static SftpClient sshLogin(FTPConfig config, SshClient ssh) throws IOException
{
  ssh.setSocketTimeout(60000);
  ssh.connect(config.host, new IgnoreHostKeyVerification());
  PasswordAuthenticationClient pwd = new PasswordAuthenticationClient();
  pwd.setUsername(config.userName);
  pwd.setPassword(config.password);
  ssh.authenticate(pwd);
  SftpClient sftp = ssh.openSftpClient();
  return sftp;
}