FTP is the most popular protocol to transfer files over the network. The protocol has been around since the very early days of computer networks and is still widely used. FTP protocol provides functions to upload, download and delete files, create and delete directories, read the contents of a directory.
There are several libraries for almost every programming language that provide set of APIs that can be used to work with the FTP commands programmatically. In Java there are several open source libraries that can be used. The most popular is Apache Commons Net library that provides easy to use APIs to work with FTP file transfer. You can go to Commons NET link for more details including several working sample applications that you can use.
SFTP however is a completely different story. To begin with, it has nothing to do with the FTP protocol and unlike the common perception, architecturally they are completely different. SFTP abbreviation is often mistaken as Secure FTP which is not entirely correct. Another perception is that SFTP is some kind of FTP over SSL or SSH. In fact SFTP is abbreviation of "SSH File Transfer Protocol". This is not FTP over SSL and not FTP over SSH. SFTP is an extension of the Secure Shell (SSH) protocol which provides the file transfer capabilities. See this SFTP Wiki page for more details.
SFTP works over a secure channel, i.e. SSH. First you connect to the secure channel, as soon as the connection is established; the server presents a public key to the client, any subsequent communication between the server and the client will be encrypted using the public key presented by the server. After establishing the connection, you then need to authenticate the communication using any supported authentication mechanism, i.e. Public Key or Username-Password. Successfully authentication creates a secure channel on which you create the SFTP connection for secure file transfer to and from the SFTP server.
That all sounds very nice and interesting, but the story starts getting muddy after that. Unfortunately there are not many complete open source implementations of SFTP in Java. What I could find so far are these two implementations of SFTP in the open source world, one is JSch and the other one is SSHTools All other implementations are either a fork of one of these two or they are in a very initial stage.
I will be using SSHTools for this example. I found that comparatively easy to use and it does what it says on the tin. You however, are welcome to try both and see which one you like the most. Both of these libraries provide very similar interfaces and are not very difficult to use. To use the SSHTools libraries, all you need to do is to download the j2ssh-core-0.2.9.jar from SSHTools website and place it on your classpath. For this example I will be creating a SFTP Client class to connect to an SFTP server using the UserName-Password authentication.
Any SFTP communication starts by creating the secure channel. First thing is to create an SSH connection using SshClient to the SFTP server and then authenticate your credentials using an instance of PasswordAuthenticationClient with your credentials and then pass it to the SshClient for authentication.
// Create SSH Connection.
SshClient ssh = new SshClient();
ssh.connect("sftp_server", new ConsoleKnownHostsKeyVerification());
// Authenticate the user
PasswordAuthenticationClient passwordAuthenticationClient = new PasswordAuthenticationClient();
passwordAuthenticationClient.setUsername("user_name");
passwordAuthenticationClient.setPassword("password");
try{
int result = ssh.authenticate(passwordAuthenticationClient);
if(result != AuthenticationProtocolState.COMPLETE){
throw new Exception("Login failed !");
}
}catch(Exception e){
throw new Exception("Authentication Failure: " + e.getMessage());
}
//Open the SFTP channel
try{
sftp = ssh.openSftpClient();
}catch(Exception e){
throw new Exception("Failed to open SFTP channel: " + e.getMessage());
}
Interesting bits to observe in this piece of code are connection and authentication related lines. First of all the ConsoleKnownHostsKeyVerification class that we pass as parameter to the connect() method. This is because when you connect to any SSH server, it supplies the public key to client and the client will use this public key for any further communication with the server. That means the login and password that we are passing to the SSH server for authentication is encrypted using this public key before it is sent over to the server for authentication.
When we pass only the host name to the connect method, it will by default try to find the known_hosts file in $HOME/.ssh/known_hosts and failing to find this file or the host in this file will prompt the user to verify the server public key signature and the following prompt will come up.
The host your.sftp.server is currently unknown to the system The host key fingerprint is: 1028: 69 54 9c 49 e5 92 59 40 5 66 c5 2e 9d 86 af ed Do you want to allow this host key? [Yes|No|Always]:
From this prompt, you have to manually enter one of these options to continue
- Yes will use this host for the current session
- No will not continue with the communication
- Always will add this host to the known host file in your system
When using the ConsoleKnownHostsKeyVerification class in the connect method, the SshClient uses the instance of this class to negotiate the protocol and exchange the key with the SSH Server on your behalf, when it returns the connection becomes ready for communication. Thus avoiding any need of user interaction to verify the server signature and manually negotiate the SSH connection. Now the credentials can be encrypted using the Public Key of the server and sent over to the server for authentication.
When your login is authenticated, then you can open an SftpClient over this SSHConnection. This is the hard work done; once you have the SftpClient then you have all the standard FTP operations at your disposal. When you finish with your FTP operations, get, put, ls, mkdir, etc. then make sure you disconnect from both the SFTP channel and the SSH connection.
public void disconnect() throws Exception{
if(sftp == null)
throw new Exception("SFTP channel is not initialized.");
if(ssh == null)
throw new Exception("SSH session is not initialized.");
try{
sftp.quit();
}catch(Exception e){
throw new Exception("Failed to disconnect from the server: " + e.getMessage());
}
try{
ssh.disconnect();
}catch(Exception e){
throw new Exception("Failed to disconnect from the server: " + e.getMessage());
}
}
There are a few lines of code that will be repeated for every SFTP operation, i.e. connection and authentication code and disconnect. Let’s create a wrapper for our SFTP communication and then we can use this wrapper in our application to do our SFTP operations. Encapsulating these methods in a few easy to use interfaces will make our life a lot easier.
package ftp;
import com.sshtools.j2ssh.SftpClient;
import com.sshtools.j2ssh.SshClient;
import com.sshtools.j2ssh.authentication.AuthenticationProtocolState;
import com.sshtools.j2ssh.authentication.PasswordAuthenticationClient;
import com.sshtools.j2ssh.transport.ConsoleKnownHostsKeyVerification;
public class SFtp {
private String host; // Remote SFTP hostname
private SshClient ssh;
private SftpClient sftp;
public SFtp(String host) {
this.host = host;
this.ssh = null;
this.sftp = null;
}
public void connect(String user, String password) throws Exception{
// Connect to SSH.
ssh = new SshClient();
try{
ssh.connect("sftp_server", new ConsoleKnownHostsKeyVerification());
}catch(Exception e){
throw new Exception("SSH connection failure: " + e.getMessage());
}
// Authenticate the user
PasswordAuthenticationClient passwordAuthenticationClient = new PasswordAuthenticationClient();
passwordAuthenticationClient.setUsername(user);
passwordAuthenticationClient.setPassword(password);
try{
int result = ssh.authenticate(passwordAuthenticationClient);
if(result != AuthenticationProtocolState.COMPLETE){
throw new Exception("Login failed !");
}
}catch(Exception e){
throw new Exception("Authenticvation Failure: " + e.getMessage());
}
//Open the SFTP channel
try{
sftp = ssh.openSftpClient();
}catch(Exception e){
throw new Exception("Failed to open SFTP channel: " + e.getMessage());
}
}
public void cd(String remoteDir) throws Exception{
if(sftp == null)
throw new Exception("SFTP channel is not initialized.");
if(remoteDir==null || remoteDir.trim().length()==0)
throw new Exception("Remote directory name is not provided.");
try{
sftp.cd(remoteDir);
}catch(Exception e){
throw new Exception("Failed to change remote directory: " + e.getMessage());
}
}
public void put(String fileName) throws Exception{
if(sftp == null)
throw new Exception("SFTP channel is not initialized.");
if(fileName==null || fileName.trim().length()==0)
throw new Exception("File name is not provided.");
//Send the file
try{
sftp.put(fileName);
}catch(Exception e){
throw new Exception("Failed to upload file: " + e.getMessage());
}
}
public void disconnect()throws Exception{
if(sftp == null)
throw new Exception("SFTP channel is not initialized.");
if(ssh == null)
throw new Exception("SSH session is not initialized.");
try{
sftp.quit();
}catch(Exception e){
throw new Exception("Failed to disconnect from the server: " + e.getMessage());
}
try{
ssh.disconnect();
}catch(Exception e){
throw new Exception("Failed to disconnect from the server: " + e.getMessage());
}
}
}
Since we are not using the SSH connection ever in our application directly, there is no need to provide any details of that in our wrapper. All we are interested in is the SFTP connection. That’s why the connect method takes the user and password as the parameters and does all the work of authenticating the users on the SSH channel and creating the SFTP connection.
In other implemented methods, cd, put, and disconnect, I am checking for a valid SFTP connection before any operation. The interesting bit here is the disconnect() method where we are making sure that both SFTP and SSH are disconnected.
And here is a sample client application that is using our wrapper to upload a file to an SFTP server.
package ftp;
public class SFTPTester {
// Set these variables for your testing environment:
private static String host = "your.sftp.server"; // Remote SFTP hostname
private static String userName = "your_user"; // Remote system login name
private static String password = "your_pswd"; // Remote system password
private static String remoteDir = "remote_dir"; // Directory on SFTP Server
public static void main(String argv[]) throws Exception {
SFtp sftp = new SFtp(host, port);
sftp.connect(userName, password);
sftp.cd(remoteDir);
sftp.put(filePath);
sftp.disconnect();
}
}
As you can see, creating a wrapper does encapsulates most of the code from your application and you end up with easy to use very simple interface to connect to your SFTP Server to upload files from your local directory. This is a very simple wrapper implementing only a few SFTP methods. Now you can add your own implementation of other FTP methods that you require.
No comments:
Post a Comment