Partner – Moderne – NPI EA (cat=Spring Boot)
announcement - icon

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Course – Black Friday 2026 – NPI EA – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

1. Overview

SSHJ is an open-source Java library that uses SSH protocols for secure communication with remote servers.

In this article, we’ll go through the basic functionality of the SSHJ library.

2. Dependencies

To use the SSHJ library, we’ll have to add the following dependency to the project:

<dependency>
    <groupId>com.hierynomus</groupId>
    <artifactId>sshj</artifactId>
    <version>0.38.0</version>
</dependency>

We can find the latest version of the SSHJ library in Maven Central.

3. SSHJ Library

The SSHJ library helps establish secure connections to remote servers over SSH.

With the SSHJ library, we can handle file upload and download using SCP or SFTP protocols. Plus, we’ve got the added bonus of being able to do local port forwarding and remote port forwarding with it too.

4. Connecting SSH Client

SSH clients can connect to the server using password or public key authentication. The SSHJ library enables us to log in using either method.

4.1. Password Authentication

We can connect to a server via an SSH port using the SSHJ library. The hostname, port, username, and password need to be specified for the SSH connection.

The SSH client connects to the server via password authentication using the authPassword() method:

String host = // ...
int port = // ...
String username = // ...
String password = // ...

SSHClient client = new SSHClient();
client.addHostKeyVerifier(new PromiscuousVerifier());
client.connect(host, port);
client.authPassword(username, password);

As we can see in the above code, we connect the client to the host using password authentication.

4.2. Public Key Authentication

We can connect to the server using the public key as well. For connecting with the public key, we need to have a file entry in the known_hosts file on the server, or we can generate a public key for the remote server on the client machine and copy the public key into authorized SSH keys on the server.

The SSH client connects to the server via public key authentication using the authPublickey() method:

String host = // ... 
String username = // ... 
File privateKeyFile = // ... 
int port = // ...
SSHClient client = new SSHClient();
KeyProvider privateKey = client.loadKeys(privateKeyFile.getPath());
client.addHostKeyVerifier(new PromiscuousVerifier());
client.connect(host, port);
client.authPublickey(username, privateKey);

We can generate a public key for the client and update it on the server to be connected. In the rest of the examples, we’ll log in using the first method, i.e., using a username and password.

5. Executing a Command via SSH

We can execute commands via the SSHJ library using the exec() method on session started by the sshClient connected to the server:

SSHClient client = new SSHClient();
Session session = sshClient.startSession();
Command cmd = session.exec("ls -lsa");
BufferedReader reader = new BufferedReader(new InputStreamReader(cmd.getInputStream()));
String line;
while ((line = reader.readLine()) != null) {
    System.out.println(line);
}
cmd.join(5, TimeUnit.SECONDS);
session.close();

As we can see in the above code, we start a session for sshClient. Then, we execute the ls -lsa command, which lists all files in the directory. We’ve then used BufferedReader to read the output of the command executed.

Similarly, other commands can also be executed here.

6. Uploading/Downloading File via SCP

We can upload a file via SCP. For upload, we use the upload() method on SCPFileTransfer object:

String filePath = // ... 
SSHClient ssh = new SSHClient();
ssh.useCompression();
ssh.newSCPFileTransfer()
  .upload(new FileSystemFile(filePath), "/upload/");

Here, we transfer a file to the upload directory on the server.

The method useCompression() adds zlib compression to preferred algorithms, which can lead to significant speedups. There’s no guarantee it’ll be successfully negotiated. If the client is already connected, then renegotiation is done; otherwise, it simply returns. We can use useCompression() before connecting the client, too.

For SCP file download, we use the download() method on SCPFileTransfer object:

String downloadPath = // ...
String fileName = // ...
SSHClient ssh = new SSHClient();
ssh.useCompression();
ssh.newSCPFileTransfer()
  .download("/upload/" + fileName, downloadPath);

Here, we download the file from the upload directory on the server to the downloadPath location on the client.

The above upload and download methods run the scp command internally, copying files from the local machine to the remote server using an SSH connection and vice versa.

7. Uploading/Downloading File via SFTP

We can upload files via SFTP. For upload, we use the put() method on SFTPClient object:

String filePath = // ...
SSHClient ssh = new SSHClient();
SFTPClient sftp = ssh.newSFTPClient();
sftp.put(new FileSystemFile(filePath), "/upload/");

Here, we transfer the file from the user’s home directory on the client to the upload directory on the server.

For SFTP download, we use the get() method on SFTPClient object:

String downloadPath = // ...
String fileName = // ...
SSHClient ssh = new SSHClient();
SFTPClient sftp = ssh.newSFTPClient();
sftp.get("/upload/" + fileName, downloadPath);
sftp.close();

Here, we download the file from the upload directory on the server to the downloadPath location on the client.

8. Local Port Forwarding

Local port forwarding is used to access services on a remote server as if the services were running on a client:

SSHClient ssh = new SSHClient();
Parameters params = new Parameters(ssh.getRemoteHostname(), 8081, "google.com", 80);
ServerSocket ss = new ServerSocket();
ss.setReuseAddress(true);
ss.bind(new InetSocketAddress(params.getLocalHost(), params.getLocalPort()));
ssh.newLocalPortForwarder(params, ss)
  .listen();

Here, we forward port 80 of the server to port 8081 of the client machine so we can access the website or service hosted on server port 80 from port 8081 on the client machine.

9. Remote Port Forwarding

Using remote port forwarding, we can expose services running on client machines to the remote server network:

SSHClient ssh = new SSHClient();
ssh.getConnection()
  .getKeepAlive()
  .setKeepAliveInterval(5);
ssh.getRemotePortForwarder()
  .bind(new Forward(8083), new SocketForwardingConnectListener(new InetSocketAddress("google.com", 80)));
ssh.getTransport()
  .join();

Here, we forward the service running on the 8083 port of the client to port 80 of the remote server. Effectively, the service running on the client machine at the 8083 port is exposed on port 80 of the remote server.

For both local and remote port forwarding, we need to ensure that proper firewall settings are in place.

10. Check Connection Drops

We need to check connection drops to monitor server connection status and health. SSHJ provides the option of checking connection drops using keep alive:

String hostName = // ...
String userName = // ...
String password = // ...
DefaultConfig defaultConfig = new DefaultConfig();
defaultConfig.setKeepAliveProvider(KeepAliveProvider.KEEP_ALIVE);
SSHClient ssh = new SSHClient(defaultConfig);

ssh.addHostKeyVerifier(new PromiscuousVerifier());
ssh.connect(hostName, 22);
ssh.getConnection()
  .getKeepAlive()
  .setKeepAliveInterval(5);
ssh.authPassword(userName, password);

Session session = ssh.startSession();
session.allocateDefaultPTY();
new CountDownLatch(1).await();
session.allocateDefaultPTY();

session.close();
ssh.disconnect();

In the above code, we can see that the configuration KeepAliveProvider.KEEP_ALIVE enables the keep alive mode for the SSHJ library.

We used setKeepAliveInterval() to set the interval between two keep-alive messages from the client.

11. Conclusion

In this article, we reviewed the basic usage and implementations of the SSHJ library. We figured out how to upload or download files using SCP and SFTP modes. Plus, we saw how to connect the SSH client using a password or public key authentication. Remote and local port forwarding is also achievable via the SSHJ library. Overall, the SSHJ library does most of the things for an SSH client in Java.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.
Partner – Moderne – NPI EA (tag=Refactoring)
announcement - icon

Modern Java teams move fast — but codebases don’t always keep up. Frameworks change, dependencies drift, and tech debt builds until it starts to drag on delivery. OpenRewrite was built to fix that: an open-source refactoring engine that automates repetitive code changes while keeping developer intent intact.

The monthly training series, led by the creators and maintainers of OpenRewrite at Moderne, walks through real-world migrations and modernization patterns. Whether you’re new to recipes or ready to write your own, you’ll learn practical ways to refactor safely and at scale.

If you’ve ever wished refactoring felt as natural — and as fast — as writing code, this is a good place to start.

Course – Black Friday 2026 – NPI EA – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW