Java – Not able to connect to Secured Channel when doing SFTP with JSch

exceptionjavajschsftp

I am trying to implement JSch to retrieve a file from remote windows sftp server to Linux.

Session session = null;
    Channel channel = null;
    ChannelSftp channelSftp = null;
        try{
           JSch jsch = new JSch();
           session = jsch.getSession("userName","hostName",22);
           session.setPassword("password");
           java.util.Properties config = new java.util.Properties();
           config.put("StrictHostKeyChecking", "no");
          session.setConfig(config);
          session.connect();
          System.out.println(session.sendKeepAliveMsg());
          channel = session.openChannel("sftp");
          channel.connect();
         }catch(Exception e){
               e.printstacktrace();
         }

I am getting following exception while running this code.

com.jcraft.jsch.JSchException: java.io.IOException: inputstream is closed
    at com.jcraft.jsch.ChannelSftp.start(ChannelSftp.java:288)
    at com.jcraft.jsch.Channel.connect(Channel.java:152)

When I debug I found:

start();

method in Channel class is throwing the exception. Is there anyway I can prevent this? I don't understand why the method is there without doing nothing.

Best Answer

Try to cast your channel into ChannelSft before the connect:

Channel channel = session.openChannel("sftp");
ChannelSftp channelSftp = (ChannelSftp) channel;
channelSftp.connect();

Related Solutions

Java – Not able to connect to SFTP using jcraft JSch

Here's the approach which had worked fine for me.

Basically it's a tunnel to your sftp host. It creates a tunnel to your sftp host via jumphost or tunnel host and grabs the files via sftpChannel from this tunneled "localhost" port (2222). I've tested it via two ssh hosts. It's working fine.

import com.jcraft.jsch.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Properties;

import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;

public class JschSftpConnect {

    public static final Logger log = LoggerFactory.getLogger(JschSftpConnect.class);
    public static final com.jcraft.jsch.Logger sshLogger = new com.jcraft.jsch.Logger() {
        public boolean isEnabled(int level) {
            return true;
        }

        public void log(int level, String message) {
            switch (level) {
                case 0:
                    log.debug(message);
                    break;
                case 1:
                    log.info(message);
                    break;
                case 2:
                    log.warn(message);
                    break;
                case 3:
                    log.error(message);
                    break;
                case 4:
                    log.error(message);
                    break;
                default:
                    break;

            }
        }
    };

    public static void main(final String args[]) {
        final String tunnelHostKey = "keyfile";
        final String tunnelHost = "sshTunnelHost";
        final String tunnelHostUser = "tunnelsshuser";

        final String sftpKey = "sftpKey";
        final String sftpHost = "sftpHost";
        final String sftpUser = "sftpuser";

        if (args.length >= 2) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Session tunnelSesssion =
                                createSession(tunnelHostKey, tunnelHost, tunnelHostUser,22);

                        tunnelSesssion.setPortForwardingL
                                (2222,sftpHost,22);

                        Session sftpSession =
                                createSession(sftpKey, "localhost", sftpUser,2222);

                        ChannelSftp sftpChannel =
                                getChannel(sftpSession);

                        if (args.length >= 2) {
                            sftpChannel.cd(args[0]);

                            log.debug("Working directory is " + sftpChannel.pwd());
                            getFileFromSftp(sftpChannel, args[1], args.length == 3 ? args[2] : args[1]);
                        }
                    } catch (Exception e) {
                        log.error(e.getMessage(), e);
                    }
                }
            }).start();
        } else {
            log.info("usage: java JschSftpConnect -cp ... <sftp dir> <sftp infile> <optional out file>");
            System.exit(-1);
        }
    }

    private static Session createSession(
            String keyFile, String host, String user,int port
            ) throws IOException, JSchException {
        JSch jsch = new JSch();
        JSch.setLogger(sshLogger);
        Path path = FileSystems.getDefault().getPath(keyFile);
        byte[] filearray = Files.readAllBytes(path);

        jsch.addIdentity("ID", filearray, null, null);
        Session session = jsch.getSession(user, host, port);
        Properties props = new Properties();
        props.put("StrictHostKeyChecking", "no");
        session.setConfig(props);

        session.setTimeout(1000);
        session.connect();
        if (!session.isConnected()) {
            throw new IOException("Session not connected");
        }
        return session;
    }

    private static ChannelSftp getChannel(Session session)throws IOException, JSchException{
        Channel ch = session.openChannel("sftp");
        log.debug("SFTP channel connected .......................");
        ChannelSftp channelSftp = (ChannelSftp) ch;
        channelSftp.connect(1000);
        return channelSftp;
    }

    private static void getFileFromSftp(ChannelSftp channelSftp, String filename, String outFile) throws SftpException, IOException {
        Path p = Paths.get(outFile != null ? outFile : "output");
        try {
            Files.copy(channelSftp.get(filename), p, REPLACE_EXISTING);
            log.debug("File '" + filename + "' is written");
            System.exit(0);
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
    }
}

Related Topic