How to do an SSL handshake in Java?

Steven 152 Published: 07/30/2024

How to do an SSL handshake in Java?

To establish a secure connection using SSL/TLS in Java, you can follow these steps:

Create an SSLContext Object: The SSLContext class is used to create and manage the context of the SSL/TLS connection. You can create an instance of this class by calling its constructor with a list of trusted certificates. 
SSLEngine engine = (SSLEngine) SSLContext.getInstance("TLS").createSSLEngine();
Set Trust Manager: The TrustManager interface is used to manage the trust decisions for the SSL/TLS connection. You can set a default trust manager using the setDefault() method. 
engine.setDelegate(new MyTrustManager());
Handshake: Before performing any IO operations, you must establish an SSL/TLS handshake by calling the startHandshake() method on the SSLEngine object. 
InputStream inputStream = // get the input stream from the server.

OutputStream outputStream = // get the output stream to the server.


engine.wrap(inputStream);


engine.startHandshake();
Get Peer's Certificate: After the handshake is complete, you can get the peer's certificate using the getPeerCertificates() method. 
X509Certificate[] certificates = engine.getPeerCertificates();

for (X509Certificate certificate : certificates) {


// handle the certificate.


}
Write and Read Data: Once the SSL/TLS connection is established, you can write data to it using the output stream and read data from it using the input stream. 
// Write data to the server.

outputStream.write(data);


outputStream.flush();


// Read data from the server.


byte[] buffer = new byte[1024];


int bytesRead;


while ((bytesRead = inputStream.read(buffer)) != -1) {


// handle the read data.


}

Example Code: Here's an example code that demonstrates how to establish an SSL/TLS connection and perform a handshake in Java:

import java.io.*;

import javax.net.ssl.*;


import java.security.KeyStore;


public class SslHandshakeExample {


public static void main(String[] args) throws Exception {


// Load the trust store.


KeyStore trustStore = KeyStore.getInstance("JKS");


trustStore.load(new FileInputStream("truststore.jks"), "password".toCharArray());


// Create an SSL context with the trust store.


SSLSocketFactory socketFactory = new SslSocketFactory(trustStore, "TLS");


// Establish a secure connection.


Socket socket = socketFactory.createSocket("server", 443);


// Perform the handshake.


SSLEngine engine = (SSLEngine) SSLContext.getInstance("TLS").createSSLEngine();


engine.setUseSessionTickets(true);


engine.startHandshake();


// Read and write data over the secure connection.


InputStream inputStream = socket.getInputStream();


OutputStream outputStream = socket.getOutputStream();


// Read from the server.


byte[] buffer = new byte[1024];


int bytesRead;


while ((bytesRead = inputStream.read(buffer)) != -1) {


System.out.println("Received: " + new String(buffer, 0, bytesRead));


}


// Write to the server.


outputStream.write("Hello from client!".getBytes());


outputStream.flush();


// Close the connection.


socket.close();


}


}

This code example establishes an SSL/TLS connection to a server on port 443 using a trust store. It then performs a handshake and reads and writes data over the secure connection.

Important Notes:

The SslSocketFactory class is not part of the standard Java API. You can implement your own socket factory or use a third-party library. In this example, we assume that you have a trust store with the server's certificate and private key. You need to load this trust store using the KeyStore class. The SSL/TLS connection is not actually used in this example code, but it demonstrates how to perform an SSL/TLS handshake in Java.

I hope this helps!

What is the SSL in Java?

I'd be happy to explain what SSL (Secure Sockets Layer) is and how it's used in Java.

What is SSL?

SSL, also known as Transport Layer Security (TLS), is a cryptographic protocol designed to provide secure communication between a client and a server over the internet. It ensures that all data exchanged between the two parties remains confidential and integrity is maintained. In other words, SSL/TLS ensures that the data transmitted is encrypted, and its authenticity is verified.

How does SSL work?

When a user requests a connection to a server using HTTPS (Hypertext Transfer Protocol Secure), the following process occurs:

Handshake: The client (usually a web browser) initiates the handshake by sending a "Hello" message to the server. This message includes information about the protocol version, cipher suite preferences, and a random session ID. Server response: The server responds with its own "Hello" message, which includes its preferred protocol version, cipher suite, and session ID. Key exchange: The client and server perform key exchanges to agree on a shared secret key. This is done using algorithms like RSA (Rivest-Shamir-Adleman) or Elliptic Curve Diffie-Hellman. Certificate validation: The client verifies the server's identity by checking its digital certificate, which contains information about the server's public key and its ownership of a specific domain name. Session setup: With the shared secret key established, the client and server can now set up their communication channel. This includes agreeing on the encryption algorithms to use (e.g., AES) and the compression method.

How is SSL used in Java?

In Java, you can leverage SSL/TLS using various libraries and frameworks. Some popular ones include:

JSSE (Java Secure Sockets Extension): JSSE is a built-in Java API for secure socket programming. It provides support for TLS/SSL protocols, including client and server-side implementation. Apache Tomcat: Apache Tomcat is an open-source web server that provides SSL/TLS support out of the box. You can configure it to use your own certificate or obtain one from a trusted Certificate Authority (CA). OkHttp: OkHttp is a popular Java library for building high-level HTTP clients and servers. It supports TLS/SSL protocols, allowing you to establish secure connections with servers.

In a Java application, you would typically create an instance of the SSLSocket or TLSSocket class (depending on the library or framework used) and configure it according to your needs. This might involve setting the truststore, keystore, and other parameters to ensure the SSL/TLS handshake is successful.

In conclusion

SSL/TLS plays a crucial role in ensuring secure communication between clients and servers over the internet. In Java, you can leverage various libraries and frameworks to implement SSL/TLS support and establish secure connections with servers. Whether you're building a web server using Apache Tomcat or creating an HTTP client with OkHttp, understanding how SSL/TLS works is essential for securing your application's data transmission.

Related Articles