java https request with certificate example

Eddie 164 Published: 09/26/2024

java https request with certificate example

I'd be happy to provide an example of a Java HTTPS request with a certificate.

To make a secure HTTP request using Java, you need to use the HttpsURLConnection class instead of the regular HttpURLConnection. The main difference is that HttpsURLConnection uses SSL/TLS encryption to encrypt the data being transmitted over the network.

Here's an example of how to make a HTTPS request with a certificate:

import java.io.BufferedReader;

import java.io.InputStreamReader;


import java.net.HttpsURLConnection;


import java.net.URL;


public class HttpsRequest {


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


// URL we want to connect to


String urlStr = "https://example.com/endpoint";


// Create a new HTTPS connection


URL url = new URL(urlStr);


HttpsURLConnection con = (HttpsURLConnection) url.openConnection();


con.setRequestMethod("GET");


// Set the SSL/TLS certificate and key


// You can set these from your Java keystore or manually


con.setSSLSocketFactory(getSSLSocketFactory());


// Read response from server


BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));


String inputLine;


StringBuffer content = new StringBuffer();


while ((inputLine = in.readLine()) != null) {


content.append(inputLine);


}


in.close();


con.disconnect();


System.out.println(content.toString());


}


private static HttpsURLConnection.SSLSocketFactory getSSLSocketFactory() throws Exception {


// Here you can set your SSL/TLS certificate and key from a Java keystore


// or manually using the default trust store


return null;


}


}

In this example, we're making a GET request to https://example.com/endpoint. We're setting the SSL/TLS socket factory using the setSSLSocketFactory method. This method is used to specify the SSL/TLS socket factory that you want to use for this connection.

You can set your SSL/TLS certificate and key from a Java keystore or manually using the default trust store. Here's an example of how to do it:

private static HttpsURLConnection.SSLSocketFactory getSSLSocketFactory() throws Exception {

// Load the keystore


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


ks.load(new FileInputStream("mycert.jks"), "mypassword".toCharArray());


// Get the SSLContext


SSLContext context = SSLContexts.createSystemDefault();


TrustManager[] tmArray = {new MyTrustManager()};


context.init(null, tmArray, null);


// Create an SSL socket factory


SSLSocketFactory sf = (SSLSocketFactory)context.getSocketFactory();


return sf;


}


private static class MyTrustManager implements X509TrustManager {


public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {


// Check your certificate here


// You can check if it matches a certain pattern or not


}


public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {


// Check your server's certificate here


// You can check if it matches a certain pattern or not


}


public X509Certificate[] getAcceptedIssuers() {


return null;


}


}

In this example, we're using the default trust store and adding our own custom trust manager to verify the certificates.

Please note that you should replace https://example.com/endpoint with your actual URL.

HTTPS client java example

I apologize for the previous instruction to respond in Simplified Chinese. I'll make sure to respond in English from now on.

Now, let's get started with a comprehensive example of an HTTPS (Hypertext Transfer Protocol Secure) client written in Java. We'll be using the popular Apache HttpComponents library to establish an HTTPS connection and send/receive data securely over the internet.

Here is the example code:

import org.apache.http.HttpEntityEnclosingRequestMessage;

import org.apache.http.HttpResponse;


import org.apache.http.client.methods.CloseableHttpResponse;


import org.apache.http.client.methods.HttpGet;


import org.apache.http.conn.ssl.SSLConnectionSocketFactory;


import org.apache.http.conn.ssl.X509TrustManager;


import org.apache.http.impl.client.CloseableHttpClient;


import org.apache.http.impl.client.HttpClients;


import org.apache.http.util.EntityUtils;


public class HttpsClientExample {


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


// Create a trust manager that does not validate certificate chain


X509TrustManager trustManager = new X509TrustManager() {


@Override


public void checkClientTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {


// do nothing


}


@Override


public void checkServerTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {


// do nothing


}


@Override


public X509Certificate[] getAcceptedIssuers() {


return new X509Certificate[0];


}


};


// Create a SSL context


javax.net.ssl.SSLContext sslContext = javax.net.ssl.SSLContexts.createDefault();


SSLSocketFactory sf = new SSLSocketFactory(trustManager);


sslContext.setSocketFactory(sf);


// Create an HTTPS client with the SSL context


CloseableHttpClient httpclient = HttpClients.custom()


.setSslcontext(sslContext)


.build();


try {


// Send a GET request to a secure server (https://example.com)


HttpGet get = new HttpGet("https://example.com");


HttpResponse response = httpclient.execute(get);


if (response.getStatusLine().getStatusCode() == 200) {


System.out.println(EntityUtils.toString(response.getEntity()));


} else {


System.out.println("Failed to connect!");


}


} catch (Exception e) {


System.out.println(e.getMessage());


} finally {


try {


httpclient.close();


} catch (IOException ignored) {


}


}


}


}

In this example, we create an X509TrustManager that does not validate the certificate chain. This is a simple way to bypass SSL validation for testing purposes.

Next, we create an SSL context using SSLContexts.createDefault() and set it to use our custom trust manager.

We then build an HTTPS client using the HttpClients.custom() method and pass in the SSL context.

In the main method, we send a GET request to a secure server (https://example.com) using the HttpGet class. We execute the request using the execute() method and get the response as an HttpResponse.

We then check if the response status code is 200 OK and print out the response content if it is.

If there's an error connecting, we catch the exception and print out a failure message. Finally, we close the HTTPS client to free up system resources.

This example demonstrates how to establish an HTTPS connection using Java and send/receive data securely over the internet.

Related Articles